def test_root_added_to_child(self):
node1 = PatternWordNode("test")
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertTrue(str(raised.exception).startswith("Cannot add root node to child node"))
def test_list_matches_no_template(self):
global total_str
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=PatternTemplateNode(
TemplateWordNode("Hello")),
sentence="HELLO",
response="Hi there")
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
total_str = ""
context.list_matches(self._client_context,
output_func=collector,
include_template=False)
self.assertEquals(
"\tMatches... Asked: HELLO 1: Match=(Topic) Node=(ONEORMORE [*]) Matched=() "
"2: Match=(Word) Node=(WORD [Hi]) Matched=(Hi) "
"3: Match=(Word) Node=(WORD [There]) Matched=(There) "
"Match score 100.00", total_str)
def test_root_added_to_child(self):
node1 = PatternWordNode("test")
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertTrue(str(raised.exception).startswith("Cannot add root node to child node"))
def test_equivalent(self):
word1 = PatternWordNode("word")
word2 = PatternWordNode("word")
word3 = PatternWordNode("word", userid="testuser")
self.assertTrue(word1.equivalent(word2))
self.assertFalse(word1.equivalent(word3))
def test_to_string(self):
word1 = PatternWordNode("test1")
self.assertEquals("WORD [test1]", word1.to_string(verbose=False))
self.assertEquals("WORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]", word1.to_string(verbose=True))
word2 = PatternWordNode("test2", "testid")
self.assertEquals("WORD [test2]", word2.to_string(verbose=False))
self.assertEquals("WORD [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test2]", word2.to_string(verbose=True))
def test_init_match_nodes_not_empty(self):
context1 = MatchContext(max_search_depth=100,
max_search_timeout=60,
matched_nodes=[
Match(Match.WORD, PatternWordNode("Hello"),
"Hello"),
Match(Match.WORD, PatternWordNode("There"),
"There")
])
self.assertEqual(100, context1.max_search_depth)
self.assertEqual(60, context1.max_search_timeout)
self.assertEqual(2, len(context1.matched_nodes))
self.assertIsInstance(context1.total_search_start, datetime.datetime)
def test_get_set_matched_nodes(self):
context = MatchContext(max_search_depth=100, max_search_timeout=60)
context._matched_nodes = [
Match(Match.WORD, PatternWordNode("Hello"), "Hello"),
Match(Match.WORD, PatternWordNode("There"), "There")
]
self.assertEqual(2, len(context.matched_nodes))
matched = context.matched_nodes
self.assertEqual(2, len(matched))
def test_remove_children_with_userid(self):
root = PatternRootNode()
root.add_child(PatternWordNode("test1"))
root.add_child(PatternWordNode("test2", userid="user1"))
root.add_child(PatternWordNode("test3", userid="user1"))
root.add_child(PatternWordNode("test4", userid="user2"))
self.assertEquals(4, len(root.children))
root.remove_children_with_userid("user1")
self.assertEquals(2, len(root.children))
def test_word_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternWordNode("test")
self.assertIsNone(node._word_node_exist(new_node1))
node.add_child(new_node1)
self.assertIsNotNone(node._word_node_exist(new_node1))
new_node2 = PatternWordNode("test", userid="testid2")
self.assertIsNone(node._word_node_exist(new_node2))
node.add_child(new_node2)
self.assertIsNotNone(node._word_node_exist(new_node2))
def test_to_xml(self):
word1 = PatternWordNode("test1")
self.assertEqual('<word word="test1"></word>\n', word1.to_xml(self._client_context))
self.assertEqual('<word userid="*" word="test1"></word>\n', word1.to_xml(self._client_context, include_user=True))
word2 = PatternWordNode("test2", userid="testid")
self.assertEqual('<word word="test2"></word>\n', word2.to_xml(self._client_context))
self.assertEqual('<word userid="testid" word="test2"></word>\n', word2.to_xml(self._client_context, include_user=True))
def test_remove_all_types_children_with_userid(self):
root = PatternRootNode()
root.add_child(PatternPriorityWordNode("test1", userid="user1"))
root.add_child(PatternWordNode("test2", userid="user1"))
root.add_child(PatternZeroOrMoreWildCardNode('^', userid="user1"))
root.add_child(PatternZeroOrMoreWildCardNode('#', userid="user1"))
root.add_child(PatternOneOrMoreWildCardNode('_', userid="user1"))
root.add_child(PatternOneOrMoreWildCardNode('*', userid="user1"))
self.assertEquals(1, len(root.priority_words))
self.assertIsNotNone(root._0ormore_hash)
self.assertIsNotNone(root._1ormore_underline)
self.assertEquals(1, len(root.children))
self.assertIsNotNone(root._0ormore_arrow)
self.assertIsNotNone(root._1ormore_star)
root.remove_children_with_userid("user1")
self.assertEquals(0, len(root.priority_words))
self.assertIsNone(root._0ormore_hash)
self.assertIsNone(root._1ormore_underline)
self.assertEquals(0, len(root.children))
self.assertIsNone(root._0ormore_arrow)
self.assertIsNone(root._1ormore_star)
def test_hash(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.assertEqual(node.wildcard, "#")
self.assertTrue(node.equivalent(PatternZeroOrMoreWildCardNode("#")))
result = node.equals(self.bot, "testid", 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.assertFalse(node.equivalent(PatternWordNode("test")))
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 test_add_that_to_node_pattern_with_set(self):
graph = PatternGraph(self._aiml_parser)
base_node = PatternWordNode("THAT_TEST")
that_element = ET.fromstring('<that>HELLO <set name="test" /> WORLD</that>')
end_node = graph.add_that_to_node(that_element, base_node)
self.assertIsNotNone(end_node)
self.assertIsNotNone(base_node)
self.assertIsNotNone(base_node.that)
self.assertIsInstance(base_node.that, PatternThatNode)
self.assertTrue(base_node.that.has_children())
self.assertIsInstance(base_node.that.children[0], PatternWordNode)
self.assertEqual(base_node.that.children[0].word, "HELLO")
self.assertTrue(base_node.that.children[0].has_children())
self.assertIsInstance(base_node.that.children[0].children[0], PatternSetNode)
self.assertEqual(base_node.that.children[0].children[0].set_name, "TEST")
self.assertTrue(base_node.that.children[0].children[0].has_children())
self.assertIsInstance(base_node.that.children[0].children[0].children[0], PatternWordNode)
self.assertEqual(base_node.that.children[0].children[0].children[0].word, "WORLD")
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())
self.assertTrue(node.equivalent(PatternPriorityWordNode("test1")))
self.assertTrue(node.equals(self.bot, "testid", "test1"))
self.assertFalse(node.equals(self.bot, "testid", "test2"))
self.assertEqual(
node.to_string(),
"PWORD [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]")
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]")
def test_dump_no_caller(self):
global str1
node = PatternNode()
self.assertIsNotNone(node)
node.add_child(PatternWordNode("test"))
node.add_child(PatternPriorityWordNode("pTest"))
node.add_child(PatternZeroOrMoreWildCardNode("^"))
node.add_child(PatternZeroOrMoreWildCardNode("#"))
node.add_child(PatternOneOrMoreWildCardNode("*"))
node.add_child(PatternOneOrMoreWildCardNode("_"))
node.add_child(PatternTemplateNode(TemplateNode()))
node.add_child(PatternSetNode({"name": "test"}, "testtext"))
node.add_child(PatternISetNode({"name": "test"}, "testtext"))
node.add_child(PatternBotNode({"name": "test"}, "testtext"))
node.add_child(PatternRegexNode({"name": ".*"}, "testtext"))
node.dump("", output_func1)
self.assertEquals(
"NODE [*] [P(1)^(1)#(1)C(5)_(1)*(1)To(0)Th(0)Te(1)] "
"PWORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[pTest] "
"ZEROORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[^] "
"ZEROORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[#] "
"ONEORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[_] "
"ONEORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[*] "
"PTEMPLATE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)] "
"WORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test] "
"SET [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] name=[TESTTEXT] "
"ISET [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] words=[TESTTEXT] "
"BOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] property=[test] "
"REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[testtext]",
str1)
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_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._client_context, "*")
self.assertTrue(node.equivalent(PatternOneOrMoreWildCardNode("_")))
result = node.equals(self._client_context, 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._client_context))
self.assertFalse(node.equivalent(PatternWordNode("test")))
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_equivalent(self):
node = PatternBotNode({}, "test1")
self.assertIsNotNone(node)
self.assertTrue(node.equivalent(PatternBotNode([], "test1")))
self.assertFalse(node.equivalent(PatternBotNode([], "test2")))
self.assertFalse(node.equivalent(PatternWordNode("test2")))
def test_add_topic_to_node_pattern_with_set(self):
graph = PatternGraph(self._client_context.brain.aiml_parser)
base_node = PatternWordNode("TOPIC_TEST")
topic_element = ET.fromstring(
'<topic>HELLO <set name="test" /> WORLD</topic>')
end_node = graph.add_topic_to_node(topic_element, base_node)
self.assertIsNotNone(end_node)
self.assertIsNotNone(base_node)
self.assertIsNotNone(base_node.topic)
self.assertIsInstance(base_node.topic, PatternTopicNode)
self.assertTrue(base_node.topic.has_children())
self.assertIsInstance(base_node.topic.children[0], PatternWordNode)
self.assertEqual(base_node.topic.children[0].word, "HELLO")
self.assertTrue(base_node.topic.children[0].has_children())
self.assertIsInstance(base_node.topic.children[0].children[0],
PatternSetNode)
self.assertEqual(base_node.topic.children[0].children[0].set_name,
"TEST")
self.assertTrue(base_node.topic.children[0].children[0].has_children())
self.assertIsInstance(
base_node.topic.children[0].children[0].children[0],
PatternWordNode)
self.assertEqual(
base_node.topic.children[0].children[0].children[0].word, "WORLD")
def test_to_json(self):
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=PatternTemplateNode(
TemplateWordNode("Hello")))
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
json_data = context.to_json()
self.assertIsNotNone(json_data)
self.assertEquals(json_data["max_search_depth"], 100)
self.assertEquals(json_data["max_search_timeout"], 60)
self.assertIsInstance(json_data["total_search_start"],
datetime.datetime)
self.assertEquals(3, len(json_data["matched_nodes"]))
self.assertEquals(
json_data["matched_nodes"][0], {
'multi_word': True,
'node': 'ONEORMORE [*]',
'type': 'Topic',
'wild_card': True,
'words': []
})
self.assertEquals(
json_data["matched_nodes"][1], {
'multi_word': False,
'node': 'WORD [Hi]',
'type': 'Word',
'wild_card': False,
'words': ["Hi"]
})
self.assertEquals(
json_data["matched_nodes"][2], {
'multi_word': False,
'node': 'WORD [There]',
'type': 'Word',
'wild_card': False,
'words': ["There"]
})
def test_word_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
node = PatternNode()
node.add_child(PatternWordNode("test"))
self.assertTrue(node.has_nodes())
self.assertTrue(node.has_children())
def test_to_json(self):
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=TemplateWordNode("Hello"))
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
sentence = Sentence(self._client_context,
"One Two Three",
matched_context=context)
json_data = sentence.to_json()
self.assertIsNotNone(json_data)
def node_from_text(word):
if word.startswith("$"):
return PatternPriorityWordNode(word[1:])
elif PatternZeroOrMoreWildCardNode.is_wild_card(word):
return PatternZeroOrMoreWildCardNode(word)
elif PatternOneOrMoreWildCardNode.is_wild_card(word):
return PatternOneOrMoreWildCardNode(word)
else:
return PatternWordNode(word)
def test_to_string(self):
word1 = PatternWordNode("test1")
self.assertEqual("WORD [test1]", word1.to_string(verbose=False))
self.assertEqual(
"WORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]",
word1.to_string(verbose=True))
word2 = PatternWordNode("test2", "testid")
self.assertEqual("WORD [test2]", word2.to_string(verbose=False))
self.assertEqual(
"WORD [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test2]",
word2.to_string(verbose=True))
def test_equals(self):
word1 = PatternWordNode("word")
word2 = PatternWordNode("word", userid="testid")
word3 = PatternWordNode("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_to_json_word_node(self):
word = PatternWordNode("Hello")
match = Match(Match.WORD, word, "Hello")
json_data = match.to_json()
self.assertIsNotNone(json_data)
self.assertEqual(json_data["type"], "Word")
self.assertEqual(json_data["node"], "WORD [Hello]")
self.assertEqual(json_data["words"], ["Hello"])
self.assertEqual(json_data["multi_word"], False)
self.assertEqual(json_data["wild_card"], False)
def test_set_get_matched_nodes(self):
context1 = MatchContext(max_search_depth=100,
max_search_timeout=60,
matched_nodes=[])
self.assertEquals([], context1.matched_nodes)
context1.set_matched_nodes(
[Match(Match.WORD, PatternWordNode("Hello"), "Hello")])
self.assertEquals(1, len(context1.matched_nodes))
def test_remove_word_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternWordNode("test")
node.add_child(child_node)
self.assertEqual(1, len(node.children))
self.assertEqual(1, len(node._children_words))
node._remove_node(child_node)
self.assertEqual(0, len(node.children))
self.assertEqual(0, len(node._children_words))
def test_equivalent(self):
word1 = PatternWordNode("word")
word2 = PatternWordNode("word")
word3 = PatternWordNode("word", userid="testuser")
self.assertTrue(word1.equivalent(word2))
self.assertFalse(word1.equivalent(word3))
def test_wildcard(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
self.assertTrue(wildcard.is_wildcard())
with self.assertRaises(ParserException):
wildcard.can_add(PatternRootNode())
wildcard.can_add(PatternWordNode("test"))
self.assertEqual(["*"], wildcard.matching_wildcards())
def test_to_xml(self):
word1 = PatternWordNode("test1")
self.assertEqual('<word word="test1"></word>\n', word1.to_xml(self._client_context))
self.assertEqual('<word userid="*" word="test1"></word>\n', word1.to_xml(self._client_context, include_user=True))
word2 = PatternWordNode("test2", userid="testid")
self.assertEqual('<word word="test2"></word>\n', word2.to_xml(self._client_context))
self.assertEqual('<word userid="testid" word="test2"></word>\n', word2.to_xml(self._client_context, include_user=True))
def test_dump_with_caller(self):
node = PatternNode()
self.assertIsNotNone(node)
node.add_child(PatternWordNode("test"))
node.add_child(PatternPriorityWordNode("pTest"))
node.add_child(PatternZeroOrMoreWildCardNode("^"))
node.add_child(PatternZeroOrMoreWildCardNode("#"))
node.add_child(PatternOneOrMoreWildCardNode("*"))
node.add_child(PatternOneOrMoreWildCardNode("_"))
node.add_child(PatternTemplateNode(TemplateNode()))
node.add_child(PatternSetNode({"name": "test"}, "testtext"))
node.add_child(PatternISetNode({"name": "test"}, "testtext"))
node.add_child(PatternBotNode({"name": "test"}, "testtext"))
node.add_child(PatternRegexNode({"name": ".*"}, "testtext"))
node.dump("", YLogger.debug)
def test_equals(self):
word1 = PatternWordNode("word")
word2 = PatternWordNode("word", userid="testid")
word3 = PatternWordNode("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_init(self):
node = PatternWordNode("test1")
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.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 test")
self.assertTrue(node.equivalent(PatternWordNode("test1")))
self.assertFalse(node.equivalent(PatternWordNode("test2")))
self.assertFalse(node.equivalent(PatternBotNode([], "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(), "WORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]")
node.add_child(PatternWordNode("test2"))
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "WORD [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]")
def test_init(self):
node = PatternWordNode("test1")
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.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternWordNode("test1")))
self.assertFalse(node.is_root())
self.assertEqual(node.to_string(), "WORD [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]")
node.add_child(PatternWordNode("test2"))
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "WORD [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)] word=[test1]")
def __init__(self, word):
PatternWordNode.__init__(self, word)
