def test_basic_set_match_as_text(self):
loader = SetLoader()
if self._bot.brain.sets.contains("SEX") is False:
self._bot.brain.sets.add_set(
"SEX",
loader.load_from_text("""
Man
Woman
"""))
self.add_pattern_to_graph(pattern="I AM A <set>sex</set>",
topic="X",
that="Y",
template="1")
context = self.match_sentence("I AM A MAN", topic="X", that="Y")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("Man", context.star(1))
context = self.match_sentence("I AM A WOMAN", topic="X", that="Y")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("Woman", context.star(1))
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_node(self):
test_bot = Bot(Brain(BrainConfiguration()), BotConfiguration())
topic_element = ET.fromstring('<topic>*</topic>')
that_element = ET.fromstring('<that>*</that>')
pattern_element = ET.fromstring("<pattern>hello world</pattern>")
test_bot.brain._aiml_parser.pattern_parser.add_pattern_to_graph(pattern_element, topic_element, that_element, None)
loader = SetLoader()
test_bot.brain.sets.add_set("testset", loader.load_from_text("""
val1
val2
val3
"""))
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateVocabularyNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEquals(root.resolve(test_bot, "testid"), '5')
def test_multi_word_set_match(self):
loader = SetLoader()
self._client_context.brain.sets.add_set("COLOR", loader.load_from_text("""
RED
RED AMBER
RED BURNT OAK
RED ORANGE
"""))
self.add_pattern_to_graph(pattern="I LIKE <set>color</set> *", topic="*", that="*", template="1")
context = self.match_sentence("I LIKE RED PAINT", topic="*", that="*")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("RED", context.star(1))
self.assertEqual("PAINT", context.star(2))
context = self.match_sentence("I LIKE RED AMBER CARS", topic="*", that="*")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("RED AMBER", context.star(1))
self.assertEqual("CARS", context.star(2))
context = self.match_sentence("I LIKE RED BURNT OAK MOTOR BIKES", topic="*", that="*")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("RED BURNT OAK", context.star(1))
self.assertEqual("MOTOR BIKES", context.star(2))
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 test_loader_from_text(self):
loader = SetLoader()
self.assertIsNotNone(loader)
the_set = loader.load_from_text("""
VAL1
VAL2
VAL3
VAL4
""")
self.assertIsNotNone(the_set)
self.assertEqual(len(the_set), 4)
self.assertIn("VAL1", the_set)
self.assertIn("VAL2", the_set)
self.assertIn("VAL3", the_set)
self.assertIn("VAL4", the_set)
def test_loader_from_text(self):
loader = SetLoader()
self.assertIsNotNone(loader)
the_set = loader.load_from_text("""
VAL1
VAL2
VAL3
VAL4
""")
self.assertIsNotNone(the_set)
self.assertEqual(len(the_set), 4)
self.assertIn("VAL1", the_set)
self.assertIn("VAL2", the_set)
self.assertIn("VAL3", the_set)
self.assertIn("VAL4", the_set)
def test_init(self):
loader = SetLoader()
self._client_context.brain._sets_collection._sets[
"TEST1"] = loader.load_from_text("""
VALUE1
VALUE2
VALUE3
VALUE4
""")
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.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
sentence = Sentence(self._client_context.brain.tokenizer,
"VALUE1 VALUE2 VALUE3 VALUE4")
self.assertTrue(node.equivalent(PatternSetNode([], "TEST1")))
result = node.equals(self._client_context, sentence, 0)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 1)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 2)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 3)
self.assertTrue(result.matched)
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 test_multi_node_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 test_loader_from_text_multi_word(self):
loader = SetLoader()
self.assertIsNotNone(loader)
the_set = loader.load_from_text("""
Val11 Val12
Val2
Val31 Val32
Val4
""")
self.assertIsNotNone(the_set)
self.assertEqual(len(the_set), 4)
self.assertIn("VAL11", the_set)
self.assertEqual([["Val11", "Val12"]], the_set['VAL11'])
self.assertIn("VAL2", the_set)
self.assertIn("VAL31", the_set)
self.assertIn("VAL4", the_set)
def test_loader_from_text(self):
loader = SetLoader()
self.assertIsNotNone(loader)
the_set = loader.load_from_text("""
Val1
Val2
Val3
Val4
""")
self.assertIsNotNone(the_set)
self.assertEqual(len(the_set), 4)
self.assertIn("VAL1", the_set)
self.assertEqual([["Val1"]], the_set['VAL1'])
self.assertIn("VAL2", the_set)
self.assertIn("VAL3", the_set)
self.assertIn("VAL4", the_set)
def test_init(self):
loader = SetLoader()
self._client_context.brain._sets_collection._sets["TEST1"] = loader.load_from_text("""
VALUE1
VALUE2
VALUE3
VALUE4
""")
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.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
sentence = Sentence(self._client_context.brain.tokenizer, "VALUE1 VALUE2 VALUE3 VALUE4")
self.assertTrue(node.equivalent(PatternSetNode([], "TEST1")))
result = node.equals(self._client_context, sentence, 0)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 1)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 2)
self.assertTrue(result.matched)
result = node.equals(self._client_context, sentence, 3)
self.assertTrue(result.matched)
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 test_equals_mixed(self):
loader = SetLoader()
self._client_context.brain._sets_collection._sets["TEST1"] = loader.load_from_text("""
VALUE1
VALUE2
VALUE3
VALUE4
""")
node1 = PatternSetNode({}, "test1")
node2 = PatternSetNode({}, "test1", userid="testid")
node3 = PatternSetNode({}, "test1", userid="testid2")
node4 = PatternSetNode({"name": "test1"}, "")
node5 = PatternSetNode({"name": "test1"}, "", userid="testid")
node6 = PatternSetNode({"name": "test1"}, "", userid="testid2")
self.assertTrue(node1.equivalent(node4))
self.assertTrue(node2.equivalent(node5))
self.assertTrue(node3.equivalent(node6))
def test_collection(self):
loader = SetLoader()
self.assertIsNotNone(loader)
collection = SetCollection()
self.assertIsNotNone(collection)
collection._sets = loader.load_from_text("""
Val1
Val2
Val3
Val4
""")
self.assertIsNotNone(collection._sets)
self.assertEqual(len(collection._sets), 4)
self.assertTrue(collection.contains('VAL1'))
self.assertTrue(collection.contains('VAL2'))
self.assertTrue(collection.contains('VAL3'))
self.assertTrue(collection.contains('VAL4'))
self.assertFalse(collection.contains('VAL5'))
def test_collection(self):
loader = SetLoader()
self.assertIsNotNone(loader)
collection = SetCollection()
self.assertIsNotNone(collection)
collection._sets = loader.load_from_text("""
VAL1
VAL2
VAL3
VAL4
""")
self.assertIsNotNone(collection._sets)
self.assertEqual(len(collection._sets), 4)
self.assertTrue(collection.contains('VAL1'))
self.assertTrue(collection.contains('VAL2'))
self.assertTrue(collection.contains('VAL3'))
self.assertTrue(collection.contains('VAL4'))
self.assertFalse(collection.contains('VAL5'))
def test_basic_set_match_as_text(self):
loader = SetLoader()
if self._client_context.brain.sets.contains("SEX") is False:
self._client_context.brain.sets.add_set("SEX", loader.load_from_text("""
Man
Woman
"""))
self.add_pattern_to_graph(pattern="I AM A <set>sex</set>", topic="X", that="Y", template="1")
context = self.match_sentence("I AM A MAN", topic="X", that="Y")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("Man", context.star(1))
context = self.match_sentence("I AM A WOMAN", topic="X", that="Y")
self.assertIsNotNone(context)
self.assertIsNotNone(context.template_node())
self.assertEqual("1", context.template_node().template.word)
self.assertEqual("Woman", context.star(1))
