def test_resolve_with_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateInputNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(0, node.index)
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)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
def test_store_logs(self):
self.tearDown()
config = FileStorageConfiguration()
config.logs_storage._dirs = [self._tmpdir]
engine = FileStorageEngine(config)
engine.initialise()
store = FileLogsStore(engine)
self.assertEqual(store.storage_engine, engine)
store.empty()
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
error_log = {"error": "logger ERROR log"}
warning_log = {"warning": "logger WARNING log"}
info_log = {"info": "logger INFO log"}
debug_log = {"debug": "logger DEBUG log"}
conversation.append_log(error_log)
conversation.append_log(warning_log)
conversation.append_log(info_log)
conversation.append_log(debug_log)
store.store_logs(client_context, conversation)
store.empty()
def test_attrib_with_html(self):
template = ET.fromstring("""
<template>
<a target="_new" href="http://www.google.com/search?q=<star />"> Google Search </a>
</template>
""")
conversation = Conversation(self._client_context)
question = Question.create_from_text(
self._client_context, "GOOGLE AIML",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "OK"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
context.add_match(Match(Match.WORD, match, "AIML"))
question.current_sentence()._matched_context = context
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
ast = self._graph.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
xml_node = ast.children[0]
self.assertIsNotNone(xml_node)
self.assertIsInstance(xml_node, TemplateXMLNode)
attribs = xml_node.attribs
self.assertEqual(2, len(attribs))
self.assertIsInstance(attribs['target'], TemplateWordNode)
target = attribs['target']
self.assertEqual(len(target.children), 0)
self.assertEqual("_new", target.word)
self.assertIsInstance(attribs['href'], TemplateNode)
href = attribs['href']
self.assertEqual(len(href.children), 3)
self.assertIsInstance(href.children[0], TemplateWordNode)
self.assertEqual('http://www.google.com/search?q=',
href.children[0].word)
self.assertIsInstance(href.children[1], TemplateNode)
self.assertEqual(1, len(href.children[1].children))
star = href.children[1].children[0]
self.assertIsInstance(star, TemplateStarNode)
self.assertIsInstance(href.children[2], TemplateWordNode)
self.assertEqual('', href.children[2].word)
result = xml_node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual(
result,
'<a target="_new" href="http://www.google.com/search?q=AIML">Google Search</a>'
)
def assert_modify_conversation_data(self, store):
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.modify_conversation_data(client_context, conversation)
store.commit()
debugInfo, _ = store.debug_conversation_data(client_context)
self.assertIsNotNone(debugInfo)
self.assertIsNotNone(debugInfo['conversations'])
conversations = debugInfo['conversations']
self.assertIsNotNone(conversations['questions'])
self.assertEqual(1, len(conversations['questions']))
question = conversations['questions'][0]
self.assertEqual(1, len(question['sentences']))
sentence = question['sentences'][0]
self.assertEqual("Hello There", sentence['question'])
self.assertEqual("Hi", sentence['response'])
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_load_logs(self):
config = RedisStorageConfiguration()
engine = RedisStorageEngine(config)
engine.initialise()
store = RedisLogsStore(engine)
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
error_log = {"error": "logger ERROR log"}
warning_log = {"warning": "logger WARNING log"}
info_log = {"info": "logger INFO log"}
debug_log = {"debug": "logger DEBUG log"}
conversation.append_log(error_log)
conversation.append_log(warning_log)
conversation.append_log(info_log)
conversation.append_log(debug_log)
store.store_logs(client_context, conversation)
logInfo = store.load_logs(client_context)
self.assertIsNotNone(logInfo)
logs = logInfo['logs']
self.assertIsNotNone(logs)
self.assertEqual(4, len(logs))
self.assertEqual({"error": "logger ERROR log"}, logs[0])
def test_parse_last_sentences_from_response(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)
response = "Hello World"
that = conversation.parse_last_sentences_from_response(
client_context, response)
self.assertEqual("Hello World", that)
response = "Hello World. Second sentence"
that = conversation.parse_last_sentences_from_response(
client_context, response)
self.assertEqual("Second sentence", that)
response = "Hello World. Second sentence. Third Sentence"
that = conversation.parse_last_sentences_from_response(
client_context, response)
self.assertEqual("Third Sentence", that)
def assert_just_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"
question1.sentence(0).matched_context = MatchContext(
max_search_depth=99,
max_search_timeout=99,
matched_nodes=[
Match(Match.WORD, PatternWordNode("Hello"), "Hello")
],
template_node=None,
sentence="HELLO",
response="Hi There")
conversation.record_dialog(question1)
store.store_conversation(client_context, conversation)
def get_conversation(self, client_context):
assert (client_context is not None)
assert (client_context.userid is not None)
if client_context.userid in self._conversations:
YLogger.info(client_context, "Retrieving conversation for client %s", client_context.userid)
conversation = self._conversations[client_context.userid]
# Load existing conversation from cache
if self.configuration.multi_client:
if self._conversation_storage is not None:
self._conversation_storage.load_conversation(client_context, conversation)
else:
YLogger.info(client_context, "Creating new conversation for client %s", client_context.userid)
conversation = Conversation(client_context)
if client_context.brain.default_variables is not None:
conversation.load_initial_variables(client_context.brain.default_variables)
self._conversations[client_context.userid] = conversation
if self._conversation_storage is not None:
self._conversation_storage.load_conversation(client_context, conversation)
if self.configuration.restore_last_topic is True:
pass
return conversation
def test_node_no_sentences(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question()
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations["testid"] = conversation
self.assertEqual("", 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 conversation_asserts(self, storage_engine, visit=True):
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 = storage_engine.conversation_store()
convo_store.store_conversation(client_context, conversation)
convo_store.commit()
def test_to_document_with_id(self):
client = TestClient()
client_context = client.create_client_context("testuser")
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)
conversation.id = '666'
doc = conversation.to_document()
self.assertEqual(
{
'_id': '666',
'clientid': 'testclient',
'userid': 'testuser',
'botid': 'bot',
'brainid': 'brain',
'conversation': {
'client_context': {
'clientid': 'testclient',
'userid': 'testuser',
'botid': 'bot',
'brainid': 'brain',
'depth': 0
},
'questions': [{
'srai':
False,
'sentences': [{
'words': ['Hello', 'world'],
'response': 'Hello matey',
'positivity': 0.0,
'subjectivity': 0.5
}],
'current_sentence_no':
-1,
'properties': {}
}],
'max_histories':
100,
'properties': {
'topic': '*'
}
}
}, doc)
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_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_store_converstion_no_logger(self):
config = LoggerStorageConfiguration()
store = MockLoggerConversationStore(config)
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)
self.assertFalse(store.logged)
def test_conversations_storage_exception_on_save_load(self):
config = RedisStorageConfiguration()
engine = RedisStorageEngine(config)
engine.initialise()
store = MockRedisConversationStore(engine, fail_write=False, fail_read=False)
client = TestClient()
client_context = client.create_client_context("user1")
conversation1 = Conversation(client_context)
store.store_conversation(client_context, conversation1)
conversation2 = Conversation(client_context)
store.load_conversation(client_context, conversation2)
def test_repr_with_id(self):
client = TestClient()
client_context = client.create_client_context("testuser")
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)
conversation.id = '1'
self.assertEquals(
"<Conversation(id='1', client='testclient', user='******', bot='bot', brain='brain')",
str(conversation))
def test_store_conversation(self):
config = LoggerStorageConfiguration()
engine = LoggerStorageEngine(config)
engine.initialise()
store = LoggerConversationStore(engine)
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)
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.word)
conversation = Conversation(self._client_context)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
question = Question.create_from_text(self._client_context,
"Hello world")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
question = Question.create_from_text(self._client_context,
"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_node_no_question(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
self._client_context.bot._conversation_mgr._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
def get_conversation(self, client_context):
assert (client_context is not None)
assert (client_context.userid is not None)
if client_context.userid in self._conversations:
YLogger.debug(client_context,
"Retrieving conversation for client %s",
client_context.userid)
conversation = self._conversations[client_context.userid]
# Load existing conversation from cache
if self.configuration.multi_client:
if self._conversation_storage is not None:
self._conversation_storage.load_conversation(
client_context, conversation)
else:
YLogger.debug(client_context,
"Creating new conversation for client %s",
client_context.userid)
conversation = Conversation(client_context)
conversation.num_categories = client_context.brain.aiml_parser.num_categories
conversation.load_initial_variables(
client_context.brain.default_variables)
self._conversations[client_context.userid] = conversation
if self._conversation_storage is not None:
self._conversation_storage.load_conversation(
client_context, conversation)
if client_context.server_mode is False:
self.load_learnf_with_userid(client_context)
if self.configuration.restore_last_topic is True:
pass
return conversation
def test_save_conversation_with_exception(self):
config = FileStorageConfiguration()
config.conversation_storage._dirs = [self._tmpdir]
engine = FileStorageEngine(config)
engine.initialise()
store = FileConversationStore(engine)
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)
def test_that_pattern(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.assertEquals("*", conversation.parse_last_sentences_from_response(""))
self.assertEquals("HELLO", conversation.parse_last_sentences_from_response("HELLO"))
self.assertEquals("HELLO", conversation.parse_last_sentences_from_response(".HELLO"))
self.assertEquals("HELLO", conversation.parse_last_sentences_from_response("HELLO."))
self.assertEquals("HELLO", conversation.parse_last_sentences_from_response(".HELLO."))
self.assertEquals("HELLO THERE", conversation.parse_last_sentences_from_response("HELLO THERE"))
self.assertEquals("THERE", conversation.parse_last_sentences_from_response("HELLO. THERE"))
self.assertEquals("THERE", conversation.parse_last_sentences_from_response("HELLO. THERE!"))
def test_store_logs(self):
config = RedisStorageConfiguration()
engine = RedisStorageEngine(config)
engine.initialise()
store = RedisLogsStore(engine)
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
error_log = {"error": "logger ERROR log"}
warning_log = {"warning": "logger WARNING log"}
info_log = {"info": "logger INFO log"}
debug_log = {"debug": "logger DEBUG log"}
conversation.append_log(error_log)
conversation.append_log(warning_log)
conversation.append_log(info_log)
conversation.append_log(debug_log)
store.store_logs(client_context, conversation)
def test_resolve_no_sentence(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateInputNode(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, "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. Are you well",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
with self.assertRaises(Exception):
root.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 = 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,
"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)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
self.assertEqual("Hello matey", 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 = TemplateResponseNode(index=1)
self.assertIsNotNone(node)
self.assertIsInstance(node.index, TemplateNode)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context,
"Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context,
"Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
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, "Hello1 response")
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.word)
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, "")
def test_resolve_to_string_three_digit(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateThatNode(index="1,1,3")
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertIsInstance(node.index, TemplateNode)
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)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
self.assertEqual("", node.resolve(self._client_context))
