def test_check_child_is_wildcard_hash(self): wildcard = MockPatternWildCardNode("*") self.assertIsNotNone(wildcard) wildcard._0ormore_hash = PatternZeroOrMoreWildCardNode('#') wildcard._0ormore_hash._template = PatternTemplateNode(TemplateNode()) context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer) sentence = Sentence(self._client_context.brain.tokenizer, "TEST SENTENCE") match = wildcard.check_child_is_wildcard("", self._client_context, context, sentence, 1, Match.WORD, 0) self.assertIsNotNone(match) context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer) sentence = Sentence(self._client_context.brain.tokenizer, "TEST") match = wildcard.check_child_is_wildcard("", self._client_context, context, sentence, 0, Match.WORD, 0) self.assertIsNotNone(match)
def test_equals_attribs(self): self._client_context.brain._sets_collection.add_set( "TEST1", { "VALUE1": [["VALUE1"]], "VALUE2": [["VALUE2"]], "VALUE3": [["VALUE3"]], "VALUE4": [["VALUE4"]] }, "teststore") node1 = PatternSetNode({"name": "test1"}, "") node2 = PatternSetNode({"name": "test1"}, "", userid="testid") node3 = PatternSetNode({"name": "test1"}, "", userid="testid2") match1 = node1.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = node2.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = node3.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def test_sentence_creation_one_word(self): sentence = Sentence(self._bot.brain.tokenizer, "One") self.assertIsNotNone(sentence) self.assertEqual(1, sentence.num_words()) with self.assertRaises(Exception): sentence.sentence.word(1) self.assertEqual("One", sentence.text())
def test_sentence_creation_one_word(self): sentence = Sentence(self._bot.brain.tokenizer, "One") self.assertIsNotNone(sentence) self.assertEqual(1, sentence.num_words()) with self.assertRaises(Exception): sentence.sentence.word(1) self.assertEqual("One", sentence.text())
def test_equals_attribs(self): loader = SetLoader() self._client_context.brain._sets_collection._sets["TEST1"] = loader.load_from_text(""" VALUE1 VALUE2 VALUE3 VALUE4 """) node1 = PatternSetNode({"name": "test1"}, "") node2 = PatternSetNode({"name": "test1"}, "", userid="testid") node3 = PatternSetNode({"name": "test1"}, "", userid="testid2") match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'VALUE1'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
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_split_into_words(self): sentence = Sentence(self._bot.brain.tokenizer, "HELLO") self.assertIsNotNone(sentence) self.assertEqual(1, sentence.num_words()) self.assertEqual("HELLO", sentence.word(0)) self.assertEqual("HELLO", sentence.words_from_current_pos(0)) with self.assertRaises(Exception): sentence.sentence.word(1) self.assertEqual("HELLO", sentence.text())
def test_sentence_creation_two_words_diff_split_char(self): tokenizer = Tokenizer(",") sentence = Sentence(tokenizer, "One,Two",) self.assertIsNotNone(sentence) self.assertEqual(2, sentence.num_words()) self.assertEqual("One", sentence.word(0)) self.assertEqual("Two", sentence.word(1)) with self.assertRaises(Exception): sentence.sentence.word(2) self.assertEqual("One,Two", sentence.text())
def test_sentence_creation_two_words_diff_split_char(self): tokenizer = Tokenizer(",") sentence = Sentence(tokenizer, "One,Two",) self.assertIsNotNone(sentence) self.assertEqual(2, sentence.num_words()) self.assertEqual("One", sentence.word(0)) self.assertEqual("Two", sentence.word(1)) with self.assertRaises(Exception): sentence.sentence.word(2) self.assertEqual("One,Two", sentence.text())
def test_equals_userid(self): word1 = PatternPriorityWordNode("word") word2 = PatternPriorityWordNode("word", userid="testid") word3 = PatternPriorityWordNode("word", userid="testid2") match1 = word1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'word'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = word2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'word'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = word3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'word'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def test_arrow(self): node = PatternZeroOrMoreWildCardNode("^") self.assertFalse(node.is_root()) self.assertFalse(node.is_priority()) self.assertTrue(node.is_zero_or_more()) self.assertFalse(node.is_one_or_more()) self.assertFalse(node.is_set()) self.assertFalse(node.is_bot()) self.assertFalse(node.is_template()) self.assertFalse(node.is_that()) self.assertFalse(node.is_topic()) self.assertTrue(node.is_wildcard()) self.assertIsNotNone(node.children) self.assertFalse(node.has_children()) sentence = Sentence(self._client_context.brain.tokenizer, "*") self.assertEqual(node.wildcard, "^") self.assertTrue(node.equivalent(PatternZeroOrMoreWildCardNode("^"))) result = node.equals(self._client_context, sentence, 0) self.assertFalse(result.matched) self.assertEqual(node.to_string(), "ZEROORMORE [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[^]") self.assertEqual('<zerormore wildcard="^">\n</zerormore>\n', node.to_xml(self._client_context)) self.assertFalse(node.equivalent(PatternWordNode("test")))
def test_equals_pattern(self): node1 = PatternRegexNode({}, "^LEGION$") node2 = PatternRegexNode({}, "^LEGION$", userid="testid") node3 = PatternRegexNode({}, "^LEGION$", userid="testid2") match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def test_init(self): node = PatternPriorityWordNode("test1") self.assertIsNotNone(node) self.assertFalse(node.is_root()) self.assertTrue(node.is_priority()) self.assertFalse(node.is_wildcard()) self.assertFalse(node.is_zero_or_more()) self.assertFalse(node.is_one_or_more()) self.assertFalse(node.is_set()) self.assertFalse(node.is_bot()) self.assertFalse(node.is_template()) self.assertFalse(node.is_that()) self.assertFalse(node.is_topic()) self.assertFalse(node.is_wildcard()) self.assertIsNotNone(node.children) self.assertFalse(node.has_children()) sentence = Sentence(self._client_context.brain.tokenizer, "test1 test2") self.assertTrue(node.equivalent(PatternPriorityWordNode("test1"))) result = node.equals(self._client_context, sentence, 0) self.assertTrue(result.matched) result = node.equals(self._client_context, sentence, 1) self.assertFalse(result.matched) self.assertEqual(node.to_string(), "PWORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]") self.assertEqual('<priority word="test1"></priority>\n', node.to_xml(self._client_context)) node.add_child(PatternWordNode("test2")) self.assertEqual(len(node.children), 1) self.assertEqual(node.to_string(), "PWORD [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]") self.assertEqual('<priority word="test1"><word word="test2"></word>\n</priority>\n', node.to_xml(self._client_context))
def test_underline(self): node = PatternOneOrMoreWildCardNode("_") self.assertIsNotNone(node) self.assertFalse(node.is_root()) self.assertFalse(node.is_priority()) self.assertFalse(node.is_zero_or_more()) self.assertTrue(node.is_one_or_more()) self.assertFalse(node.is_set()) self.assertFalse(node.is_bot()) self.assertFalse(node.is_template()) self.assertFalse(node.is_that()) self.assertFalse(node.is_topic()) self.assertTrue(node.is_wildcard()) self.assertIsNotNone(node.children) self.assertFalse(node.has_children()) self.assertEqual(node.wildcard, "_") sentence = Sentence(self._bot.brain.tokenizer, "*") self.assertTrue(node.equivalent(PatternOneOrMoreWildCardNode("_"))) result = node.equals(self._bot, "testid", sentence, 0) self.assertFalse(result.matched) self.assertEqual(node.to_string(), "ONEORMORE [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[_]") self.assertEqual('<oneormore wildcard="_">\n</oneormore>\n', node.to_xml(self._bot, self._clientid)) self.assertFalse(node.equivalent(PatternWordNode("test")))
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_init(self): self._client_context.brain.properties.add_property("test1", "value1") node = PatternBotNode({}, "test1") self.assertIsNotNone(node) self.assertFalse(node.is_root()) self.assertFalse(node.is_priority()) self.assertFalse(node.is_wildcard()) self.assertFalse(node.is_zero_or_more()) self.assertFalse(node.is_one_or_more()) self.assertFalse(node.is_set()) self.assertTrue(node.is_bot()) self.assertFalse(node.is_template()) self.assertFalse(node.is_that()) self.assertFalse(node.is_topic()) self.assertFalse(node.is_wildcard()) self.assertTrue(node.equivalent(PatternBotNode([], "test1"))) self.assertFalse(node.equivalent(PatternBotNode([], "test2"))) sentence = Sentence(self._client_context.brain.tokenizer, "value1 value2") result = node.equals(self._client_context, sentence, 0) self.assertTrue(result.matched) self.assertEqual(0, result.word_no) result = node.equals(self._client_context, sentence, 1) self.assertFalse(result.matched) self.assertEqual(1, result.word_no) self.assertEqual(node.to_string(), "BOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] property=[test1]") self.assertEqual('<bot property="test1">\n</bot>', node.to_xml(self._client_context))
def test_check_child_is_wildcard_no_wildcard_children(self): wildcard = MockPatternWildCardNode("*") self.assertIsNotNone(wildcard) context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer) sentence = Sentence(self._client_context.brain.tokenizer, "TEST SENTENCE") match = wildcard.check_child_is_wildcard("", self._client_context, context, sentence, 0, Match.WORD, 0) self.assertIsNone(match)
def get_exit_response(self, client_context): if self.exit_response_srai is not None: sentence = Sentence(client_context.brain.tokenizer, self.exit_response_srai) exit_response = client_context.brain.ask_question(client_context, sentence) if exit_response is None or not exit_response: exit_response = self.exit_response return exit_response else: return self.exit_response
def test_check_spelling_before_false(self): spelling_config = BotSpellingConfiguration() spelling_config._classname = "programytest.spelling.test_base.MockSpellingChecker" spelling_config._check_before = False storage_factory = None spell_checker = SpellingChecker.initiate_spellchecker( spelling_config, storage_factory) client = TestClient() client_context = client.create_client_context("user1") sentence = Sentence(client_context.brain.tokenizer, "Hello word") spell_checker.check_spelling_before(client_context, sentence) self.assertEqual(sentence.text(), "Hello word")
def test_bot_init_with_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.norvig.NorvigSpellingChecker" bot_config.spelling._corpus = os.path.dirname(__file__) + os.sep + "test_corpus.txt" bot_config.spelling._check_before = True bot_config.spelling._check_and_retry = True bot = Bot(bot_config) self.assertIsNotNone(bot) test_sentence = Sentence(bot.brain.tokenizer, "locetion") bot.check_spelling_before(test_sentence) self.assertIsNotNone(test_sentence) self.assertEqual("LOCATION", test_sentence.text()) test_sentence = Sentence(bot.brain.tokenizer, "locetion") response = bot.check_spelling_and_retry(self._client_context, test_sentence) self.assertIsNone(response)
def get_default_response(self, client_context): if self.default_response_srai is not None: sentence = Sentence(client_context.brain.tokenizer, self.default_response_srai) default_response = client_context.brain.ask_question(client_context, sentence) if default_response is None or not default_response: default_response = self.default_response return default_response else: return self.default_response
def test_equivalent_property(self): self._client_context.brain.properties.add_property("test1", "value1") bot1 = PatternBotNode({"property": "test1"}, None) bot2 = PatternBotNode({"property": "test1"}, None, userid="testid") bot3 = PatternBotNode({"property": "test1"}, None, userid="testid2") match1 = bot1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'value1'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = bot2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'value1'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = bot3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'value1'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def test_bot_init_with_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.norvig.NorvigSpellingChecker" bot_config.spelling._corpus = os.path.dirname(__file__) + os.sep + "test_corpus.txt" bot_config.spelling._check_before = True bot_config.spelling._check_and_retry = True bot = Bot(bot_config) self.assertIsNotNone(bot) test_sentence = Sentence(bot.brain.tokenizer, "locetion") bot.check_spelling_before(test_sentence) self.assertIsNotNone(test_sentence) self.assertEqual("LOCATION", test_sentence.text()) test_sentence = Sentence(bot.brain.tokenizer, "locetion") response = bot.check_spelling_and_retry(self._client_context, test_sentence) self.assertIsNone(response)
def get_initial_question(self, client_context): if self.initial_question_srai is not None: sentence = Sentence(client_context.brain.tokenizer, self.initial_question_srai) initial_question = client_context.brain.ask_question(client_context, sentence) if initial_question is None or not initial_question: initial_question = self.initial_question return initial_question else: return self.initial_question
def test_equals_template(self): self._client_context.brain.regex_templates.add_regex("LEGION", re.compile("^LEGION$", re.IGNORECASE)) node1 = PatternRegexNode({"template": "LEGION"}, "") node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid") node3 = PatternRegexNode({"template": "LEGION"}, "", userid="testid2") match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
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_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_words_from_current_pos(self): sentence = Sentence(self._bot.brain.tokenizer, "One Two Three") self.assertIsNotNone(sentence) self.assertEqual("One Two Three", sentence.words_from_current_pos(0)) self.assertEqual("Two Three", sentence.words_from_current_pos(1)) self.assertEqual("Three", sentence.words_from_current_pos(2)) with self.assertRaises(Exception): self.assertEqual("Three", sentence.words_from_current_pos(3)) self.assertEqual("One Two Three", sentence.text())
def failed_authentication(self, bot, clientid): if logging.getLogger().isEnabledFor(logging.ERROR): logging.error("[%s] failed authentication!") if self.authentication.configuration.denied_srai is not None: match_context = self._aiml_parser.match_sentence(bot, clientid, Sentence(bot.brain.tokenizer, self.authentication.configuration.denied_srai), topic_pattern="*", that_pattern="*") if match_context is not None: return self.resolve_matched_template(bot, clientid, match_context) return self.authentication.configuration.denied_text
def get_exit_response(self, clientid): if self.exit_response_srai is not None: sentence = Sentence(self.brain.tokenizer, self.exit_response_srai) exit_response = self.brain.ask_question(self, clientid, sentence, srai=False) if exit_response is None or not exit_response: exit_response = self.exit_response return exit_response else: return self.exit_response
def test_multi_word_set(self): loader = SetLoader() self._client_context.brain._sets_collection._sets[ "TEST1"] = loader.load_from_text(""" Red Red Amber Red Brown """) node = PatternSetNode([], "test1") self.assertIsNotNone(node) self.assertFalse(node.is_root()) self.assertFalse(node.is_priority()) self.assertFalse(node.is_wildcard()) self.assertFalse(node.is_zero_or_more()) self.assertFalse(node.is_one_or_more()) self.assertTrue(node.is_set()) self.assertFalse(node.is_bot()) self.assertFalse(node.is_template()) self.assertFalse(node.is_that()) self.assertFalse(node.is_topic()) self.assertFalse(node.is_wildcard()) self.assertTrue(node.equivalent(PatternSetNode([], "TEST1"))) self.assertIsNotNone(node.children) self.assertFalse(node.has_children()) sentence = Sentence(self._client_context.brain.tokenizer, "RED Red BROWN red AMBER") result = node.equals(self._client_context, sentence, 0) self.assertTrue(result.matched) self.assertEquals(result.matched_phrase, "Red") self.assertEquals(result.word_no, 0) result = node.equals(self._client_context, sentence, result.word_no + 1) self.assertTrue(result.matched) self.assertEquals(result.matched_phrase, "Red Brown") result = node.equals(self._client_context, sentence, result.word_no + 1) self.assertTrue(result.matched) self.assertEquals(result.matched_phrase, "Red Amber") self.assertEqual( node.to_string(), "SET [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] name=[TEST1]") self.assertEqual('<set name="TEST1">\n</set>', node.to_xml(self._client_context))
def get_default_response(self, clientid): if self.default_response_srai is not None: sentence = Sentence(self.brain.tokenizer, self.default_response_srai) default_response = self.brain.ask_question(self, clientid, sentence, srai=False) if default_response is None or not default_response: default_response = self.default_response return default_response else: return self.default_response
def test_number(self): self._client_context.brain.dynamics.add_dynamic_set('number', "programy.dynamic.sets.numeric.IsNumeric", None) node = PatternSetNode([], "NUMBER") self.assertIsNotNone(node) sentence = Sentence(self._client_context.brain.tokenizer, "12 XY") result = node.equals(self._client_context, sentence, 0) self.assertTrue(result.matched) result = node.equals(self._client_context, sentence, result.word_no+1) self.assertFalse(result.matched)
def test_equals(self): node1 = PatternISetNode([], "test1, test2, test3") node2 = PatternISetNode([], "test1, test2, test3", userid="testid") node3 = PatternISetNode([], "test1, test2, test3", userid="testid2") match1 = node1.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'test1'), 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = node2.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'test1'), 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = node3.equals( self._client_context, Sentence(self._client_context.brain.tokenizer, 'test1'), 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def get_initial_question(self, clientid): if self.initial_question_srai is not None: sentence = Sentence(self.brain.tokenizer, self.initial_question_srai) initial_question = self.brain.ask_question(self, clientid, sentence, srai=False) if initial_question is None or not initial_question: initial_question = self.initial_question return initial_question else: return self.initial_question
def test_words_from_current_pos(self): sentence = Sentence(self._bot.brain.tokenizer, "One Two Three") self.assertIsNotNone(sentence) self.assertEqual("One Two Three", sentence.words_from_current_pos(0)) self.assertEqual("Two Three", sentence.words_from_current_pos(1)) self.assertEqual("Three", sentence.words_from_current_pos(2)) with self.assertRaises(Exception): self.assertEqual("Three", sentence.words_from_current_pos(3)) self.assertEqual("One Two Three", sentence.text())
def match_sentence(self, client_context, pattern_sentence, topic_pattern, that_pattern): topic_sentence = Sentence(client_context.brain.tokenizer, topic_pattern) that_sentence = Sentence(client_context.brain.tokenizer, that_pattern) YLogger.debug(client_context, "AIML Parser matching sentence [%s], topic=[%s], that=[%s] ", pattern_sentence.text(), topic_pattern, that_pattern) sentence = Sentence(client_context.brain.tokenizer) sentence.append_sentence(pattern_sentence) sentence.append_word('__TOPIC__') sentence.append_sentence(topic_sentence) sentence.append_word('__THAT__') sentence.append_sentence(that_sentence) YLogger.debug(client_context, "Matching [%s]", sentence.words_from_current_pos(0)) context = MatchContext(max_search_depth=client_context.bot.configuration.max_search_depth, max_search_timeout=client_context.bot.configuration.max_search_timeout, tokenizer=client_context.brain.tokenizer) template = self._pattern_parser._root_node.match(client_context, context, sentence) if template is not None: context._template_node = template context.list_matches(client_context) # Save the matched context for the associated sentence pattern_sentence.matched_context = context return context return None
def test_sentence_creation_spaces(self): sentence = Sentence(self._bot.brain.tokenizer, " ") self.assertIsNotNone(sentence) self.assertEqual(0, sentence.num_words()) with self.assertRaises(Exception): sentence.sentence.word(0)