def test_resolve_no_defaults_inside_topic(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateTopicStarNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer)
context.add_match(Match(Match.TOPIC, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations["testid"] = conversation
self.assertEqual("Matched", node.resolve(self._client_context))
def test_resolve_no_defaults_inside_topic(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateTopicStarNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer)
context.add_match(Match(Match.TOPIC, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("Matched", node.resolve(self._client_context))
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.index)
conversation = Conversation(self._client_context)
self._client_context.bot._conversations["testid"] = conversation
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "What did you say")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
def test_resolve_no_sentence(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=3)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(3, node.index)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you. Are you well")
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "")
def test_node_with_star(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question.create_from_text(
self._client_context, "Hello world",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(
self._client_context, "How are you",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.tokenizer)
context.add_match(Match(Match.WORD, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
self.assertEqual("Matched", root.resolve(self._client_context))
def test_resolve_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateInputNode(index=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.index)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context,
"Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context,
"How are you. Are you well")
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "How are you")
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation("testid", self._bot)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
response = root.resolve(self._bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateThatNode(question=1, sentence=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.question)
self.assertEqual(1, node.sentence)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("Hello matey", node.resolve(self._client_context))
def test_resolve_no_sentence(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=3)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(3, node.index)
conversation = Conversation("testid", self._bot)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._bot.brain.tokenizer,
"How are you. Are you well")
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
response = root.resolve(self._bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "")
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.index)
conversation = Conversation(self._client_context)
self._client_context.bot._conversations["testid"] = conversation
question = Question.create_from_text(
self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
question = Question.create_from_text(
self._client_context.brain.tokenizer, "What did you say")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
def test_question_create_from_question(self):
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello There")
new_question = Question.create_from_question(question)
self.assertIsNotNone(new_question)
self.assertEqual(1, len(new_question.sentences))
self.assertEqual("Hello There", question.sentence(0).text())
with self.assertRaises(Exception):
question.sentence(1)
def get_question(self, client_context, pre_processed, srai):
if srai is False:
return Question.create_from_text(client_context.brain.tokenizer,
pre_processed)
else:
return Question.create_from_text(client_context.brain.tokenizer,
pre_processed,
split=False)
def test_question_create_from_question(self):
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello There")
new_question = Question.create_from_question(question)
self.assertIsNotNone(new_question)
self.assertEqual(1, len(new_question.sentences))
self.assertEqual("Hello There", question.sentence(0).text())
with self.assertRaises(Exception):
question.sentence(1)
def get_question(self, client_context, pre_processed, srai):
if srai is False:
return Question.create_from_text(client_context,
pre_processed,
srai=srai)
else:
return Question.create_from_text(client_context,
pre_processed,
split=False,
srai=srai)
def test_conversation(self):
brain_config = BrainConfiguration()
test_brain = Brain(brain_config)
bot_config = BotConfiguration()
bot_config.conversations._max_histories = 3
test_bot = Bot(test_brain, bot_config)
conversation = Conversation("test", test_bot)
self.assertIsNotNone(conversation)
self.assertIsNotNone(conversation._bot)
self.assertIsNotNone(conversation._clientid)
self.assertEqual(conversation._clientid, "test")
self.assertEqual(0, len(conversation._questions))
self.assertEqual(3, conversation._max_histories)
self.assertEqual(1, len(conversation._properties))
with self.assertRaises(Exception):
conversation.current_question()
with self.assertRaises(Exception):
conversation.previous_nth_question(0)
question1 = Question.create_from_text(test_bot.brain.tokenizer,
"Hello There")
conversation.record_dialog(question1)
self.assertEqual(question1, conversation.current_question())
with self.assertRaises(Exception):
conversation.previous_nth_question(1)
question2 = Question.create_from_text(test_bot.brain.tokenizer,
"Hello There Again")
conversation.record_dialog(question2)
self.assertEqual(question2, conversation.current_question())
self.assertEqual(question1, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(3)
question3 = Question.create_from_text(test_bot.brain.tokenizer,
"Hello There Again Again")
conversation.record_dialog(question3)
self.assertEqual(question3, conversation.current_question())
self.assertEqual(question2, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(4)
# Max Histories for this test is 3
# Therefore we should see the first question, pop of the stack
question4 = Question.create_from_text(test_bot.brain.tokenizer,
"Hello There Again Again Again")
conversation.record_dialog(question4)
self.assertEqual(question4, conversation.current_question())
self.assertEqual(question3, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(5)
def get_question(self, client_context, pre_processed, srai):
'''
Khởi tạo câu hỏi từ đoạn text đã được pre_process
'''
if srai is False:
return Question.create_from_text(client_context.brain.tokenizer,
pre_processed,
srai=srai)
else:
return Question.create_from_text(client_context.brain.tokenizer,
pre_processed,
split=False,
srai=srai)
def test_conversation(self):
client = TestClient()
client_context = ClientContext(client, "testid")
client_context.bot = Bot(BotConfiguration(), client)
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
conversation = Conversation(client_context)
self.assertIsNotNone(conversation)
self.assertEqual(0, len(conversation._questions))
self.assertEqual(3, conversation._max_histories)
self.assertEqual(1, len(conversation._properties))
with self.assertRaises(Exception):
conversation.current_question()
with self.assertRaises(Exception):
conversation.previous_nth_question(0)
question1 = Question.create_from_text(client_context, "Hello There")
conversation.record_dialog(question1)
self.assertEqual(question1, conversation.current_question())
with self.assertRaises(Exception):
conversation.previous_nth_question(1)
question2 = Question.create_from_text(client_context,
"Hello There Again")
conversation.record_dialog(question2)
self.assertEqual(question2, conversation.current_question())
self.assertEqual(question1, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(3)
question3 = Question.create_from_text(client_context,
"Hello There Again Again")
conversation.record_dialog(question3)
self.assertEqual(question3, conversation.current_question())
self.assertEqual(question2, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(4)
# Max Histories for this test is 3
# Therefore we should see the first question, pop of the stack
question4 = Question.create_from_text(client_context,
"Hello There Again Again Again")
conversation.record_dialog(question4)
self.assertEqual(question4, conversation.current_question())
self.assertEqual(question3, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(5)
def test_node_no_star(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
def test_local_set(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", question.property("name"))
def test_global_get(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = False
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._bot.get_conversation(self._clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
conversation.set_property("name", "keith")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
def test_local_no_value(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self._bot.brain.properties.add_property("default-get", "unknown")
conversation = self._bot.get_conversation(self._clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
conversation.record_dialog(question)
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_local_set(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", question.property("name"))
def assert_conversation_storage(self,
store,
can_empty=True,
test_load=True):
if can_empty is True:
store.empty()
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
store.store_conversation(client_context, conversation)
store.commit()
if test_load is True:
conversation2 = Conversation(client_context)
store.load_conversation(client_context, conversation2)
self.assertEqual(1, len(conversation2.questions))
self.assertEqual(1, len(conversation2.questions[0].sentences))
self.assertEqual("Hello There",
conversation2.questions[0].sentences[0].text())
self.assertEqual("Hi",
conversation2.questions[0].sentences[0].response)
def test_type2_node_global(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("cond1", condition_type=2)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(value=TemplateWordNode("value1"))
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(value=TemplateWordNode("value2"))
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode()
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
self._bot.conversation(self._clientid).set_property('cond1', "value2")
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
self._bot.conversation(self._clientid).record_dialog(question)
self._bot.conversation(self._clientid).current_question().set_property(
"cond1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def setUp(self):
self._client = TemplateGraphClient()
self._client_context = self._client.create_client_context("testid")
self._graph = self._client_context.bot.brain.aiml_parser.template_parser
self.test_sentence = Sentence(self._client_context.brain.tokenizer,
"test sentence")
test_node = PatternOneOrMoreWildCardNode("*")
self.test_sentence._matched_context = MatchContext(
max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.tokenizer)
self.test_sentence._matched_context._matched_nodes = [
Match(Match.WORD, test_node, 'one'),
Match(Match.WORD, test_node, 'two'),
Match(Match.WORD, test_node, 'three'),
Match(Match.WORD, test_node, 'four'),
Match(Match.WORD, test_node, 'five'),
Match(Match.WORD, test_node, 'six'),
Match(Match.TOPIC, test_node, '*'),
Match(Match.THAT, test_node, '*')
]
conversation = self._client_context.bot.get_conversation(
self._client_context)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_local_no_value(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property("default-get", "unknown")
conversation = self._client_context.bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_global_set_allow_overrides_with_default(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
self._client_context.bot.configuration.override_propertys = True
self._client_context.brain.properties.pairs.append(["name", "fred"])
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = False
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", conversation.property("name"))
def test_global_set_allow_overrides_with_default(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
self._client_context.bot.configuration.override_propertys = True
self._client_context.brain.properties.pairs.append(["name", "fred"])
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = False
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", conversation.property("name"))
def test_init_context_and_converstion(self):
client = TestClient()
client_context = client.create_client_context("tesuser")
convo = Convo(client_context)
question = Question.create_from_text(client_context, "Hello world")
question.current_sentence()._response = "Hello matey"
convo.record_dialog(question)
conversation = Conversation(client_context, convo)
self.assertIsNotNone(conversation)
self.assertEqual(client_context.client.id, conversation.clientid)
self.assertEqual(client_context.userid, conversation.userid)
self.assertEqual(client_context.bot.id, conversation.botid)
self.assertEqual(client_context.brain.id, conversation.brainid)
self.assertIsNotNone(conversation.conversation)
doc = conversation.to_document()
self.assertEqual({'clientid': 'testclient', 'userid': 'tesuser', 'botid': 'bot', 'brainid': 'brain', 'conversation': {'client_context': {'clientid': 'testclient', 'userid': 'tesuser', 'botid': 'bot', 'brainid': 'brain', 'depth': 0}, 'questions': [{'sentences': [{'question': 'Hello world', 'response': 'Hello matey'}], 'srai': False, 'properties': {}, 'current_sentence_no': -1}], 'max_histories': 100, 'properties': {'topic': '*'}}},
doc)
conversation2 = Conversation.from_document(client_context, doc)
self.assertIsNotNone(conversation2)
self.assertEqual(conversation2.clientid, conversation.clientid)
self.assertEqual(conversation2.userid, conversation.userid)
self.assertEqual(conversation2.botid, conversation.botid)
self.assertEqual(conversation2.brainid, conversation.brainid)
def test_conversation(self):
client_context = ClientContext(TestClient(), "testid")
client_context.bot = Bot(BotConfiguration())
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
conversation = Conversation(client_context)
self.assertIsNotNone(conversation)
self.assertEqual(0, len(conversation._questions))
self.assertEqual(3, conversation._max_histories)
self.assertEqual(1, len(conversation._properties))
with self.assertRaises(Exception):
conversation.current_question()
with self.assertRaises(Exception):
conversation.previous_nth_question(0)
question1 = Question.create_from_text(client_context.brain.tokenizer, "Hello There")
conversation.record_dialog(question1)
self.assertEqual(question1, conversation.current_question())
with self.assertRaises(Exception):
conversation.previous_nth_question(1)
question2 = Question.create_from_text(client_context.brain.tokenizer, "Hello There Again")
conversation.record_dialog(question2)
self.assertEqual(question2, conversation.current_question())
self.assertEqual(question1, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(3)
question3 = Question.create_from_text(client_context.brain.tokenizer, "Hello There Again Again")
conversation.record_dialog(question3)
self.assertEqual(question3, conversation.current_question())
self.assertEqual(question2, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(4)
# Max Histories for this test is 3
# Therefore we should see the first question, pop of the stack
question4 = Question.create_from_text(client_context.brain.tokenizer, "Hello There Again Again Again")
conversation.record_dialog(question4)
self.assertEqual(question4, conversation.current_question())
self.assertEqual(question3, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(5)
def test_next_previous_nth_sentences(self):
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello There. How Are you")
self.assertEqual("How Are you", question.current_sentence().text())
self.assertEqual("How Are you",
question.previous_nth_sentence(0).text())
self.assertEqual("Hello There",
question.previous_nth_sentence(1).text())
def test_node_no_star(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation("testid", self._bot)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._bot.brain.tokenizer,
"How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._bot, self._clientid))
def test_question_create_from_sentence(self):
sentence = Sentence(self._bot.brain.tokenizer, "One Two Three")
question = Question.create_from_sentence(sentence)
self.assertIsNotNone(question)
self.assertEqual(1, len(question.sentences))
self.assertEqual(sentence.text(), question.sentence(0).text())
with self.assertRaises(Exception):
question.sentence(1)
def test_question_create_from_sentence(self):
sentence = Sentence(self._bot.brain.tokenizer, "One Two Three")
question = Question.create_from_sentence(sentence)
self.assertIsNotNone(question)
self.assertEqual(1, len(question.sentences))
self.assertEqual(sentence.text(), question.sentence(0).text())
with self.assertRaises(Exception):
question.sentence(1)
def test_question_multi_sentence(self):
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello There. How Are you")
self.assertIsNotNone(question)
self.assertEqual(2, len(question.sentences))
self.assertEqual("Hello There", question.sentence(0).text())
self.assertEqual("How Are you", question.sentence(1).text())
with self.assertRaises(Exception):
question.sentence(2)
def test_question_multi_sentence(self):
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello There. How Are you")
self.assertIsNotNone(question)
self.assertEqual(2, len(question.sentences))
self.assertEqual("Hello There", question.sentence(0).text())
self.assertEqual("How Are you", question.sentence(1).text())
with self.assertRaises(Exception):
question.sentence(2)
def load_conversation(self, client_context, conversation):
db_conversations = self._storage_engine.session.query(
Conversation).filter(
Conversation.clientid == client_context.client.id,
Conversation.userid == client_context.userid)
question = Question()
conversation.questions.append(question)
current_question = 0
for conversation in db_conversations:
if conversation.question != current_question:
question = Question()
conversation.questions.append(question)
sentence = Sentence(client_context.bot.brain.tokenizer,
conversation.sentence)
sentence.response = conversation.response
question.sentences.append(sentence)
def test_conversation_operations(self):
config = BotConversationsConfiguration()
mgr = ConversationManager(config)
if os.path.exists("./storage/conversations"):
shutil.rmtree("./storage/conversations")
client = TestClient()
client.add_conversation_store("./storage/conversations")
mgr.initialise(client.storage_factory)
client_context = client.create_client_context("user1")
conversation = mgr.get_conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
mgr.save_conversation(client_context)
question2 = Question.create_from_text(client_context, "Hello There Again")
question2.sentence(0).response = "Hi Again"
conversation.record_dialog(question2)
mgr.save_conversation(client_context)
question3 = Question.create_from_text(client_context, "Hello There Again Again")
question3.sentence(0).response = "Hi Again Again"
conversation.record_dialog(question3)
mgr.save_conversation(client_context)
self.assertEqual(len(mgr.conversations), 1)
mgr.empty()
self.assertEqual(len(mgr.conversations), 0)
conversation = mgr.get_conversation(client_context)
self.assertEqual(len(mgr.conversations), 1)
self.assertIsNotNone(conversation)
self.assertEqual(len(conversation.questions), 3)
if os.path.exists("./storage/conversations"):
shutil.rmtree("./storage/conversations")
def test_combine_answers(self):
question = Question()
sentence1 = Sentence(self._bot.brain.tokenizer, "Hi")
sentence1._response = "Hello"
question._sentences.append(sentence1)
sentence2 = Sentence(self._bot.brain.tokenizer, "Hi Again")
question._sentences.append(sentence2)
sentence2._response = "World"
self.assertEqual(2, len(question._sentences))
self.assertEqual(question._sentences[0]._response, "Hello")
self.assertEqual(question._sentences[1]._response, "World")
sentences = question.combine_sentences()
self.assertEqual("Hi. Hi Again", sentences)
combined = question.combine_answers()
self.assertIsNotNone(combined)
self.assertEqual(combined, "Hello. World")
def test_combine_answers(self):
question = Question()
sentence1 = Sentence(self._bot.brain.tokenizer, "Hi")
sentence1._response = "Hello"
question._sentences.append(sentence1)
sentence2 = Sentence(self._bot.brain.tokenizer, "Hi Again")
question._sentences.append(sentence2)
sentence2._response = "World"
self.assertEqual(2, len(question._sentences))
self.assertEqual(question._sentences[0]._response, "Hello")
self.assertEqual(question._sentences[1]._response, "World")
sentences = question.combine_sentences()
self.assertEqual("Hi. Hi Again", sentences)
combined = question.combine_answers()
self.assertIsNotNone(combined)
self.assertEqual(combined, "Hello. World")
def test_node_no_sentences(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation("testid", self._bot)
question = Question()
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._bot, self._clientid))
def test_node_with_star(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer)
context.add_match(Match(Match.WORD, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("Matched", root.resolve(self._client_context))
def test_store_conversation(self):
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
convo_store = ConversationStore()
with self.assertRaises(NotImplementedError):
convo_store.store_conversation(client_context, conversation)
def test_transcripts_questions_with_props(self):
client = TranscriptAdminExtensionClient()
client_context = client.create_client_context("testid")
question = Question.create_from_sentence(Sentence(client_context.brain.tokenizer, "Hello World"))
conversation = client_context.bot.get_conversation(client_context)
conversation.record_dialog(question)
extension = TranscriptAdminExtension()
self.assertIsNotNone(extension)
result = extension.execute(client_context, "PROPERTIES")
self.assertIsNotNone(result)
self.assertEquals("Questions:<br /><ul><li>Hello World - </li></ul><br />Properties:<br /><ul><li>topic = *</li></ul><br />", result)
def test_question_one_sentence(self):
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello There")
self.assertIsNotNone(question)
self.assertEqual(1, len(question.sentences))
def test_question_no_sentences_blank(self):
question = Question.create_from_text(self._bot.brain.tokenizer, " ")
self.assertIsNotNone(question)
self.assertEqual(0, len(question.sentences))
def test_next_previous_nth_sentences(self):
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello There. How Are you")
self.assertEqual("How Are you", question.current_sentence().text())
self.assertEqual("How Are you", question.previous_nth_sentence(0).text())
self.assertEqual("Hello There", question.previous_nth_sentence(1).text())
def get_question(self, client_context, pre_processed, srai):
if srai is False:
return Question.create_from_text(client_context.brain.tokenizer, pre_processed, srai=srai)
else:
return Question.create_from_text(client_context.brain.tokenizer, pre_processed, split=False, srai=srai)
