def test_question_sentiment(self): question = Question.create_from_text(self.client_context, "Hello There. How Are you") for sentence in question.sentences: sentence.calculate_sentinment_score(self.client_context) positivity, subjectivity = question.calculate_sentinment_score() self.assertEqual(0.0, positivity) self.assertEqual(0.0, subjectivity) question = Question.create_from_text( self.client_context, "I hate you. Your car is rubbish") question.recalculate_sentinment_score(self.client_context) positivity, subjectivity = question.calculate_sentinment_score() self.assertEqual(-0.4, positivity) self.assertEqual(0.45, subjectivity)
def create_from_json(self, json_data): for key, value in json_data['properties'].items(): self._properties[key] = value for json_question in json_data['questions']: self._questions.append( Question.from_json(self._client_context, json_question)) self.recalculate_sentiment_score(self._client_context)
def test_combine_answers(self): question = Question() sentence1 = Sentence(self._client_context.brain.tokenizer, "Hi") sentence1._response = "Hello" question._sentences.append(sentence1) sentence2 = Sentence(self._client_context.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(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_node_no_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) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation self.assertEqual("", root.resolve(self._client_context))
def from_json(self, client_context, json_data): if json_data is not None: json_questions = json_data['questions'] for json_question in json_questions: json_sentences = json_question['sentences'] for json_sentence in json_sentences: question = Question.create_from_text( self._client_context, json_sentence['question']) question.sentence(0).response = json_sentence['response'] self._questions.append(question) self.recalculate_sentiment_score(client_context)
def test_conversation_sentiment(self): conversation = Conversation(self.client_context) question1 = Question.create_from_text(self.client_context, "I am so unhappy") conversation.record_dialog(question1) question2 = Question.create_from_text(self.client_context, "I do not like the colour red") conversation.record_dialog(question2) question3 = Question.create_from_text(self.client_context, "Custard makes me feel sick") conversation.record_dialog(question3) conversation.recalculate_sentiment_score(self.client_context) positivity, subjectivity = conversation.calculate_sentiment_score() self.assertEqual(-0.4380952380952381, positivity) self.assertEqual(0.5857142857142857, subjectivity)
def test_question_multi_sentence(self): question = Question.create_from_text(self._client_context, "Hello There. How Are you") self.assertIsNotNone(question) self.assertEqual(2, len(question.sentences)) self.assertEqual("Hello There", question.sentence(0).text(self._client_context)) self.assertEqual("How Are you", question.sentence(1).text(self._client_context)) with self.assertRaises(Exception): question.sentence(2)
def test_next_previous_nth_sentences(self): question = Question.create_from_text(self._client_context, "Hello There. How Are you") self.assertEqual( "How Are you", question.current_sentence().text(self._client_context)) self.assertEqual( "How Are you", question.previous_nth_sentence(0).text(self._client_context)) self.assertEqual( "Hello There", question.previous_nth_sentence(1).text(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_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.assertEquals(2, len(attribs)) self.assertIsInstance(attribs['target'], TemplateWordNode) target = attribs['target'] self.assertEquals(len(target.children), 0) self.assertEquals("_new", target.word) self.assertIsInstance(attribs['href'], TemplateNode) href = attribs['href'] self.assertEquals(len(href.children), 3) self.assertIsInstance(href.children[0], TemplateWordNode) self.assertEquals('http://www.google.com/search?q=', href.children[0].word) self.assertIsInstance(href.children[1], TemplateNode) self.assertEquals(1, len(href.children[1].children)) star = href.children[1].children[0] self.assertIsInstance(star, TemplateStarNode) self.assertIsInstance(href.children[2], TemplateWordNode) self.assertEquals('', href.children[2].word) result = xml_node.resolve(self._client_context) self.assertIsNotNone(result) self.assertEquals(result, '<a target="_new" href="http://www.google.com/search?q=AIML">Google Search</a>')
def test_resolve_with_defaults_inside_topic(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateTopicStarNode() 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, "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.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", 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_combine_answers(self): question = Question() sentence1 = Sentence(self._client_context, "Hi") sentence1._response = "Hello" question.sentences.append(sentence1) sentence2 = Sentence(self._client_context, "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._client_context) self.assertEqual("Hi. Hi Again", sentences) combined = question.combine_answers() self.assertIsNotNone(combined) self.assertEqual(combined, "Hello. World") self.assertEquals("Hi = Hello, Hi Again = World", question.debug_info(self._client_context))
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.assertEqual("Questions:<br /><ul><li>Hello World - </li></ul><br />Properties:<br /><ul><li>topic = *</li></ul><br />", result)
def test_sentiment_feeling_last_10(self): extension = SentimentExtension() self.assertIsNotNone(extension) # Need to create a conversation first conversation = self.client_context.bot.get_conversation(self.client_context) self.assertIsNotNone(conversation) question = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter) conversation.record_dialog(question) result = extension.execute(self.client_context, "SENTIMENT FEELING LAST 10") self.assertIsNotNone(result) self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
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 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_conversation_in_db(self): config = SQLStorageConfiguration() engine = SQLStorageEngine(config) engine.initialise() store = SQLConversationStore(engine) store.empty() client = TestClient() client_context = client.create_client_context("user1") conversation1 = Conversation(client_context) conversation1.properties['ckey1'] = "cvalue1" conversation1.properties['ckey2'] = "cvalue2" question1 = Question.create_from_text(client_context, "Hello There") question1.sentence(0).response = "Hi" question1.sentence(0)._positivity = 0.5 question1.sentence(0)._subjectivity = 0.6 question1.properties['qkey1'] = "qvalue1" question1.properties['qkey2'] = "qvalue2" conversation1.record_dialog(question1) store.store_conversation(client_context, conversation1) store.commit() conversation2 = Conversation(client_context) store.load_conversation(client_context, conversation2) self.assertEquals(conversation2.properties['ckey1'], "cvalue1") self.assertEquals(conversation2.properties['ckey2'], "cvalue2") self.assertEquals(conversation2.questions[0].sentence(0).response, "Hi") self.assertEquals(conversation2.questions[0].sentence(0)._positivity, 0.5) self.assertEquals(conversation2.questions[0].sentence(0)._subjectivity, 0.6) self.assertEquals(conversation2.questions[0].properties['qkey1'], "qvalue1") self.assertEquals(conversation2.questions[0].properties['qkey2'], "qvalue2") store.empty()
def _read_questions_from_db(self, client_context, conversationid, conversation): questiondaos = self._storage_engine.session.query(QuestionDAO).\ filter(QuestionDAO.conversationid==conversationid) for questiondao in questiondaos: YLogger.debug(client_context, "Loading question %s", questiondao) question = Question(questiondao.srai) self._read_properties_from_db(client_context, conversationid, questiondao.id, ConversationPropertyDAO.QUESTION, question.properties) self._read_sentences_from_db(client_context, questiondao.id, question) conversation.record_dialog(question)
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_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_get_user_global_missing(self): client = PropertiesAdminExtensionClient() client_context = client.create_client_context("testid") question = Question() conversation = client_context.bot.get_conversation(client_context) conversation.record_dialog(question) conversation.set_property("PROP1", "Value1") extension = PropertiesAdminExtension() self.assertIsNotNone(extension) result = extension.execute(client_context, "GET USER GLOBAL") self.assertIsNotNone(result) self.assertEqual("Missing variable name for GET USER", result)
def test_question_set_sentencesy(self): question = Question.create_from_text(self._client_context, "") self.assertIsNotNone(question) self.assertEqual(0, len(question.sentences)) question.sentences = [ Sentence(self._client_context, "Sentence One"), Sentence(self._client_context, "Sentence Two") ] self.assertEqual(2, len(question.sentences)) self.assertEqual("Sentence One = N/A, Sentence Two = N/A", question.debug_info(self._client_context)) self.assertEquals(-1, question.current_sentence_no) question.current_sentence_no = 1 self.assertEquals(1, question.current_sentence_no)
def test_get_user_other(self): client = PropertiesAdminExtensionClient() client_context = client.create_client_context("testid") question = Question() conversation = client_context.bot.get_conversation(client_context) conversation.record_dialog(question) conversation.set_property("PROP1", "Value1") extension = PropertiesAdminExtension() self.assertIsNotNone(extension) result = extension.execute(client_context, "GET USER XXXX") self.assertIsNotNone(result) self.assertEqual("Invalid GET USER var type [XXXX]", result)
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_nlu_match_as_no_nlu_result(self): self.add_pattern_to_graph(pattern='<nlu intent="transportation"/>', topic="*", that="*", template="1") conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) context = self.match_sentence("YEMPTY", topic="*", that="*") self.assertIsNone(context)
def test_get_user_incomplete(self): client = PropertiesAdminExtensionClient() client_context = client.create_client_context("testid") question = Question() conversation = client_context.bot.get_conversation(client_context) conversation.record_dialog(question) conversation.set_property("PROP1", "Value1") extension = PropertiesAdminExtension() self.assertIsNotNone(extension) result = extension.execute(client_context, "GET USER") self.assertIsNotNone(result) self.assertEqual("Invalid syntax for GET USER, LOCAL or GLOBAL", result)
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) self.assertTrue( 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(client_context)) self.assertEqual("Hi", conversation2.questions[0].sentences[0].response) client2 = TestClient() client_context2 = client2.create_client_context("user2") if test_load is True: conversation3 = Conversation(client_context) self.assertFalse( store.load_conversation(client_context2, conversation3)) if can_empty is True: store.empty()
def test_nluslot_no_item(self): root = TemplateNode() node = TemplateNluSlotNode() node._slotName = TemplateWordNode("nlu_slot") node._itemName = TemplateWordNode("startOffset") root.append(node) conversation = self._client_context.bot.get_conversation( self._client_context) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) nlu_result = '{"intents": [], "slots": [{"slot": "nlu_slot", "entity": "value"}]}' conversation.current_question().set_property("__SYSTEM_NLUDATA__", nlu_result) result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("unknown", result)