def __init__(self, wildcard, userid='*'):
PatternNode.__init__(self, userid)
if wildcard not in self.matching_wildcards():
raise ParserException(
"%s not in valid wildcards %s" %
(wildcard, ", ".join(self.matching_wildcards())))
self._wildcard = wildcard
def __init__(self, attribs, text, userid='*', element=None, brain=None):
PatternNode.__init__(self, userid)
if 'name' in attribs:
self._property = attribs['name']
elif 'property' in attribs:
self._property = attribs['property']
elif text:
self._property = text
else:
raise ParserException(
"No parameter specified as attribute or text",
xml_element=element,
nodename='bot(pattern)')
if self._property == '':
raise ParserException(
"No parameter specified as attribute or text",
xml_element=element,
nodename='bot(pattern)')
if brain is not None:
if brain.properties.has_property(self._property) is False:
raise ParserException("Bot_property[%s] not found" %
self._property,
xml_element=element,
nodename='bot(pattern)')
def __init__(self, attribs, text, userid='*', element=None):
# @TODO This does not handle upper and lower case
PatternNode.__init__(self, userid)
self._pattern_text = None
self._pattern_template = None
self._pattern = None
self._is_form = False
self._is_NotOption = False
if 'pattern' in attribs:
self._pattern_text = attribs['pattern']
elif 'template' in attribs:
self._pattern_template = attribs['template']
if self._pattern_template == '':
raise ParserException("Specified Parameter is empty", xml_element=element, nodename='regex')
elif 'form' in attribs:
form_text = attribs['form']
if form_text.count('(?!') > 0:
self._is_NotOption = True
self._is_form = True
self._pattern_text = form_text
elif text:
self._pattern_text = text
else:
raise ParserException("No Parameter specified as attribute or text", xml_element=element, nodename='regex')
if self._pattern_text is not None:
if self._pattern_text == '':
raise ParserException("Specified Parameter is empty", xml_element=element, nodename='regex')
try:
self._pattern = re.compile(self._pattern_text, re.IGNORECASE)
except Exception:
raise ParserException("invalid regex expression (unable re.compile)", xml_element=element, nodename='regex')
def __init__(self, attribs, text, userid='*', element=None, brain=None):
PatternNode.__init__(self, userid)
if 'name' in attribs:
name = attribs['name']
elif text:
name = text
else:
raise ParserException("No name specified as attribute or text",
xml_element=element,
nodename='set(pattern)')
if name == '':
raise ParserException("No name specified as attribute or text",
xml_element=element,
nodename='set(pattern)')
name = JapaneseLanguage.zenhan_normalize(name)
set_name = name.upper()
if brain is not None:
if brain.sets.storename(set_name) is None:
if brain.dynamics.is_dynamic_set(set_name) is False:
raise ParserException("Set[%s] not found" % set_name,
xml_element=element,
nodename='set(pattern)')
self._set_name = set_name
def __init__(self, attribs, text):
PatternNode.__init__(self)
if 'name' in attribs:
self._set_name = attribs['name'].upper()
elif text:
self._set_name = text.upper()
else:
raise ParserException("Invalid set node, no name specified as attribute or text")
def __init__(self, attribs, text, userid='*'):
PatternNode.__init__(self, userid)
if 'name' in attribs:
self._set_name = attribs['name'].upper()
elif text:
self._set_name = text.upper()
else:
raise ParserException("Invalid set node, no name specified as attribute or text")
def test_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
node = PatternNode()
node._children.append(PatternNode())
self.assertTrue(node.has_nodes())
def can_add(self, new_node: PatternNode):
if new_node.is_root():
raise ParserException("Cannot add root node to existing root node")
if new_node.is_topic():
raise ParserException("Cannot add topic node to root node")
if new_node.is_that():
raise ParserException("Cannot add that node to root node")
if new_node.is_template():
raise ParserException("Cannot add template node to root node")
def can_add(self, new_node: PatternNode):
if new_node.is_root():
raise ParserException("Cannot add root node to existing root node")
if new_node.is_topic():
raise ParserException("Cannot add topic node to root node")
if new_node.is_that():
raise ParserException("Cannot add that node to root node")
if new_node.is_template():
raise ParserException("Cannot add template node to root node")
def __init__(self, attribs, text, userid='*', element=None):
PatternNode.__init__(self, userid)
if 'name' in attribs:
self._set_name = attribs['name'].upper()
if self._set_name == '':
raise ParserException("No name specified as attribute or text", xml_element=element, nodename='set(pattern)')
elif text:
self._set_name = text.upper()
else:
raise ParserException("No name specified as attribute or text", xml_element=element, nodename='set(pattern)')
def test_remove_zeroormore_hash_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternZeroOrMoreWildCardNode("#")
node.add_child(child_node)
self.assertIsNotNone(node._0ormore_hash)
node._remove_node(child_node)
self.assertIsNone(node._0ormore_hash)
def test_remove_oneormore_star_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternOneOrMoreWildCardNode("*")
node.add_child(child_node)
self.assertIsNotNone(node._1ormore_star)
node._remove_node(child_node)
self.assertIsNone(node._1ormore_star)
def test_priority_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_priority_words())
node = PatternNode()
node.add_child(PatternPriorityWordNode("pTest"))
self.assertTrue(node.has_nodes())
self.assertTrue(node.has_priority_words())
def test_remove_priority_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternPriorityWordNode("test")
node.add_child(child_node)
self.assertEquals(1, len(node.priority_words))
node._remove_node(child_node)
self.assertEquals(0, len(node.priority_words))
def __init__(self, word, userid='*'):
PatternNode.__init__(self, userid)
chars = []
for ch in word:
if ChineseLanguage.is_language(ch):
chars.append(" %s " % ch)
else:
chars.append(ch)
text = "".join(chars).strip()
word = re.sub(' +', ' ', text)
self._word = word
def test_template_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_template())
node = PatternNode()
node.add_template(PatternTemplateNode(None))
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_template())
def test_topic_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_topic())
node = PatternNode()
node.add_topic(PatternTopicNode())
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_topic())
def test_that_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_that())
node = PatternNode()
node.add_that(PatternThatNode())
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_that())
def __init__(self, attribs, text, userid='*'):
PatternNode.__init__(self, userid)
if 'name' in attribs:
self._property = attribs['name']
elif 'property' in attribs:
self._property = attribs['property']
elif text:
self._property = text
else:
raise ParserException(
"Invalid bot node, neither name or property specified as attribute or text"
)
def test_remove_word_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternWordNode("test")
node.add_child(child_node)
self.assertEquals(1, len(node.children))
self.assertEquals(1, len(node._children_words))
node._remove_node(child_node)
self.assertEquals(0, len(node.children))
self.assertEquals(0, len(node._children_words))
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 __init__(self, attribs, text, userid='*'):
PatternNode.__init__(self, userid)
self._words = []
if 'words' in attribs:
words = attribs['words'].upper()
elif text:
words = text.upper()
else:
raise ParserException("Invalid iset node, no words specified as attribute or text")
self._parse_words(words)
self._iset_name = "iset_%d"%(PatternISetNode.iset_count)
PatternISetNode.iset_count += 1
def __init__(self, attribs, text, userid='*', element=None, brain=None):
PatternNode.__init__(self, userid)
self._pattern_text = None
self._pattern_template = None
self._pattern = None
self._is_form = False
self._is_NotOption = False
if 'pattern' in attribs:
self._pattern_text = attribs['pattern']
elif 'template' in attribs:
name = attribs['template']
if name == '':
raise ParserException("Specified Template Parameter is empty",
xml_element=element,
nodename='regex')
template_name = name.upper()
if brain is not None:
if brain.regex_templates.has_regex(template_name) is False:
raise ParserException("Template[%s] not found" %
template_name,
xml_element=element,
nodename='regex')
self._pattern_template = template_name
elif 'form' in attribs:
form_text = attribs['form']
if form_text.count('(?!') > 0:
self._is_NotOption = True
self._is_form = True
self._pattern_text = form_text
elif text:
self._pattern_text = text
else:
raise ParserException(
"No Parameter specified as attribute or text",
xml_element=element,
nodename='regex')
if self._pattern_text is not None:
if self._pattern_text == '':
raise ParserException("Specified Parameter is empty",
xml_element=element,
nodename='regex')
try:
self._pattern = re.compile(self._pattern_text, re.IGNORECASE)
except Exception:
raise ParserException(
"invalid regex expression (unable re.compile)",
xml_element=element,
nodename='regex')
def test_one_or_more_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternOneOrMoreWildCardNode("*")
self.assertIsNone(node._one_or_more_node_exist(new_node1))
node.add_child(new_node1)
self.assertIsNotNone(node._one_or_more_node_exist(new_node1))
new_node2 = PatternOneOrMoreWildCardNode("*", userid="testid2")
self.assertIsNone(node._one_or_more_node_exist(new_node2))
node.add_child(new_node2)
self.assertIsNotNone(node._one_or_more_node_exist(new_node2))
def test_that_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternThatNode()
self.assertIsNone(node._that_node_exist(new_node1))
node.add_that(new_node1)
self.assertIsNotNone(node._that_node_exist(new_node1))
new_node2 = PatternThatNode(userid="testid2")
self.assertIsNotNone(node._that_node_exist(new_node2))
node.add_that(new_node2)
self.assertIsNotNone(node._that_node_exist(new_node2))
def test_regex_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternRegexNode([], "test")
self.assertIsNone(node._regex_node_exist(new_node1))
node.add_child(new_node1)
self.assertIsNotNone(node._regex_node_exist(new_node1))
new_node2 = PatternRegexNode([], "test", userid="testid2")
self.assertIsNone(node._regex_node_exist(new_node2))
node.add_child(new_node2)
self.assertIsNotNone(node._regex_node_exist(new_node2))
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_template_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternTemplateNode(TemplateNode())
self.assertIsNone(node._template_node_exist(new_node1))
node.add_template(new_node1)
self.assertIsNotNone(node._template_node_exist(new_node1))
new_node2 = PatternTemplateNode(TemplateNode(), userid="testid2")
self.assertIsNotNone(node._template_node_exist(new_node2))
node.add_template(new_node2)
self.assertIsNotNone(node._template_node_exist(new_node2))
def test_consume_out_of_words_without_template(self):
node = PatternNode()
self.assertIsNotNone(node)
match_context = MatchContext(max_search_depth=100,
max_search_timeout=100)
words = Sentence(self._client_context)
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNone(result)
def test_init(self):
node = PatternRootNode()
self.assertIsNotNone(node)
self.assertTrue(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())
self.assertTrue(node.equivalent(PatternRootNode()))
self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node.add_child(PatternNode())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)]")
def __init__(self, attribs, text, userid='*'):
PatternNode.__init__(self, userid)
self._pattern_text = None
self._pattern_template = None
self._pattern = None
if 'pattern' in attribs:
self._pattern_text = attribs['pattern']
elif 'template' in attribs:
self._pattern_template = attribs['template']
elif text:
self._pattern_text = text
else:
raise ParserException("Invalid regex node, neither pattern or template specified as attribute or text")
if self._pattern_text is not None:
self._pattern = re.compile(self._pattern_text)
def __init__(self, attribs, text):
PatternNode.__init__(self)
self._pattern_text = None
self._pattern_template = None
if 'pattern' in attribs:
self._pattern_text = attribs['pattern']
elif 'template' in attribs:
self._pattern_template = attribs['template']
elif len(text) > 0:
self._pattern_text = text
else:
raise ParserException(
"Invalid regex node, neither pattern or template specified as attribute or text"
)
if self._pattern_text is not None:
self._pattern = re.compile(self._pattern_text)
def __init__(self, attribs, text, userid='*'):
# @TODO This does not handle upper and lower case
PatternNode.__init__(self, userid)
self._pattern_text = None
self._pattern_template = None
self._pattern = None
if 'pattern' in attribs:
self._pattern_text = attribs['pattern']
elif 'template' in attribs:
self._pattern_template = attribs['template']
elif text:
self._pattern_text = text
else:
raise ParserException("Invalid regex node, neither pattern or template specified as attribute or text")
if self._pattern_text is not None:
self._pattern = re.compile(self._pattern_text, re.IGNORECASE)
def __init__(self, attribs, text, userid='*'):
self._set_name = None
self._additional = {}
PatternNode.__init__(self, userid)
for attrib in attribs:
if attrib == 'name':
self._set_name = attribs['name'].upper()
else:
self._additional[attrib] = attribs[attrib].upper()
if text:
self._set_name = text.upper()
if self._set_name is None:
raise ParserException(
"Invalid set node, no name specified as attribute or text")
def test_consume_that(self):
node = PatternNode()
self.assertIsNotNone(node)
node.add_that(PatternThatNode())
match_context = MatchContext(max_search_depth=100,
max_search_timeout=100)
words = Sentence(self._client_context, text="__THAT__")
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNone(result)
def test_priority_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_priority_words())
node = PatternNode()
node.add_child(PatternPriorityWordNode("pTest"))
self.assertTrue(node.has_nodes())
self.assertTrue(node.has_priority_words())
def test_remove_regex_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternRegexNode({"name": ".*"}, "testtext")
node.add_child(child_node)
self.assertTrue(node._regex_node_exist(child_node))
node._remove_node(child_node)
self.assertFalse(node._regex_node_exist(child_node))
def test_template_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_template())
node = PatternNode()
node.add_template(PatternTemplateNode(None))
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_template())
def test_that_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_that())
node = PatternNode()
node.add_that(PatternThatNode())
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_that())
def test_topic_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_topic())
node = PatternNode()
node.add_topic(PatternTopicNode())
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_topic())
def test_one_or_more_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternOneOrMoreWildCardNode("*")
self.assertIsNone(node._one_or_more_node_exist(new_node1))
node.add_child(new_node1)
self.assertIsNotNone(node._one_or_more_node_exist(new_node1))
new_node2 = PatternOneOrMoreWildCardNode("*", userid="testid2")
self.assertIsNone(node._one_or_more_node_exist(new_node2))
node.add_child(new_node2)
self.assertIsNotNone(node._one_or_more_node_exist(new_node2))
def test_that_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternThatNode()
self.assertIsNone(node._that_node_exist(new_node1))
node.add_that(new_node1)
self.assertIsNotNone(node._that_node_exist(new_node1))
new_node2 = PatternThatNode(userid="testid2")
self.assertIsNotNone(node._that_node_exist(new_node2))
node.add_that(new_node2)
self.assertIsNotNone(node._that_node_exist(new_node2))
def test_template_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternTemplateNode(TemplateNode())
self.assertIsNone(node._template_node_exist(new_node1))
node.add_template(new_node1)
self.assertIsNotNone(node._template_node_exist(new_node1))
new_node2 = PatternTemplateNode(TemplateNode(), userid="testid2")
self.assertIsNotNone(node._template_node_exist(new_node2))
node.add_template(new_node2)
self.assertIsNotNone(node._template_node_exist(new_node2))
def test_regex_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternRegexNode([], "test")
self.assertIsNone(node._regex_node_exist(new_node1))
node.add_child(new_node1)
self.assertIsNotNone(node._regex_node_exist(new_node1))
new_node2 = PatternRegexNode([], "test", userid="testid2")
self.assertIsNone(node._regex_node_exist(new_node2))
node.add_child(new_node2)
self.assertIsNotNone(node._regex_node_exist(new_node2))
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_equals_ignore_case(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertTrue(node.equals_ignore_case("", ""))
self.assertTrue(node.equals_ignore_case("test", "test"))
self.assertTrue(node.equals_ignore_case("Test", "test"))
self.assertTrue(node.equals_ignore_case("test", "Test"))
self.assertTrue(node.equals_ignore_case("TEST", "test"))
self.assertTrue(node.equals_ignore_case("test", "TEST"))
self.assertFalse(node.equals_ignore_case("test", "TESTX"))
self.assertFalse(node.equals_ignore_case("testX", "TEST"))
self.assertFalse(node.equals_ignore_case(None, "TEST"))
self.assertFalse(node.equals_ignore_case("testX", None))
self.assertFalse(node.equals_ignore_case(None, None))
def __init__(self, attribs, text, userid='*', element=None):
PatternNode.__init__(self, userid)
if 'name' in attribs:
self._property = attribs['name']
elif 'property' in attribs:
self._property = attribs['property']
elif text:
self._property = text
else:
raise ParserException(
"No parameter specified as attribute or text",
xml_element=element,
nodename='bot(pattern)')
if self._property == '':
raise ParserException(
"No parameter specified as attribute or text",
xml_element=element,
nodename='bot(pattern)')
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_equals_ignore_case(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertTrue(node.equals_ignore_case("", ""))
self.assertTrue(node.equals_ignore_case("test", "test"))
self.assertTrue(node.equals_ignore_case("Test", "test"))
self.assertTrue(node.equals_ignore_case("test", "Test"))
self.assertTrue(node.equals_ignore_case("TEST", "test"))
self.assertTrue(node.equals_ignore_case("test", "TEST"))
self.assertFalse(node.equals_ignore_case("test", "TESTX"))
self.assertFalse(node.equals_ignore_case("testX", "TEST"))
self.assertFalse(node.equals_ignore_case(None, "TEST"))
self.assertFalse(node.equals_ignore_case("testX", None))
self.assertFalse(node.equals_ignore_case(None, None))
def test_add_child(self):
node = PatternNode()
self.assertIsNotNone(node)
priority_word1 = PatternPriorityWordNode("pword")
priority_word2 = PatternPriorityWordNode("pword")
node.add_child(priority_word1)
new_node = node.add_child(priority_word2)
self.assertEqual(new_node, priority_word1)
arrow_node1 = PatternZeroOrMoreWildCardNode("^")
arrow_node2 = PatternZeroOrMoreWildCardNode("^")
node.add_child(arrow_node1)
new_node = node.add_child(arrow_node2)
self.assertEqual(new_node, arrow_node1)
def test_get_tabs(self):
node = PatternNode()
self.assertIsNotNone(node)
self._client_context.bot.configuration._tab_parse_output = True
self.assertEquals("", node.get_tabs(self._client_context, 0))
self.assertEquals(" ", node.get_tabs(self._client_context, 1))
self.assertEquals(" ", node.get_tabs(self._client_context, 5))
self._client_context.bot.configuration._tab_parse_output = False
self.assertEquals("", node.get_tabs(self._client_context, 0))
self.assertEquals("", node.get_tabs(self._client_context, 1))
self.assertEquals("", node.get_tabs(self._client_context, 5))
def test_init(self):
node = PatternNode()
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.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.assertFalse(node.has_children())
self.assertIsNotNone(node.children)
self.assertFalse(node.equivalent(PatternNode()))
self.assertEqual(node.to_string(), "NODE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node.add_child(PatternNode())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "NODE [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)]")
def __init__(self):
PatternNode.__init__(self)
def __init__(self, word):
PatternNode.__init__(self)
self._word = word
def __init__(self, template, userid='*'):
PatternNode.__init__(self, userid)
self._template = template
def equivalent(self, other: PatternNode)->bool:
if other.is_root():
if self.userid == other.userid:
return True
return False
def test_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assert_child_node_exists(node, PatternWordNode("word"), PatternWordNode("word"))
self.assert_child_node_exists(node, PatternPriorityWordNode("priority"), PatternPriorityWordNode("priority"))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('_'), PatternOneOrMoreWildCardNode('_'))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('*'), PatternOneOrMoreWildCardNode('*'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('#'), PatternZeroOrMoreWildCardNode('#'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('^'), PatternZeroOrMoreWildCardNode('^'))
self.assert_child_node_exists(node, PatternSetNode({}, "setname"), PatternSetNode([], "setname"))
self.assert_child_node_exists(node, PatternBotNode({}, "botname"), PatternBotNode([], "botname"))
self.assert_child_node_exists(node, PatternISetNode({}, "word1 word2"), PatternISetNode([], "word1 word2"))
self.assert_child_node_exists(node, PatternRegexNode({"pattern": "^LEGION$"}, None), PatternRegexNode({"pattern": "^LEGION$"}, None))
self.assert_child_node_exists(node, PatternRegexNode({"template": "LEGION"}, None), PatternRegexNode({"template": "LEGION"}, None))
topic1 = PatternTopicNode()
topic2 = PatternTopicNode()
self.assertIsNone(node._node_exists(topic1))
node.add_topic(topic1)
new_node = node._node_exists(topic1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
new_node = node.add_topic(topic2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
that1 = PatternThatNode()
that2 = PatternThatNode()
self.assertIsNone(node._node_exists(that1))
node.add_that(that1)
new_node = node._node_exists(that1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
new_node = node.add_that(that2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
template1 = PatternTemplateNode(None)
template2 = PatternTemplateNode(None)
self.assertIsNone(node._node_exists(template1))
node.add_template(template1)
new_node = node._node_exists(template1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
new_node = node.add_template(template2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
test_result = """<priority word="priority"></priority>
<zerormore wildcard="^">
</zerormore>
<zerormore wildcard="#">
</zerormore>
<oneormore wildcard="_">
</oneormore>
<oneormore wildcard="*">
</oneormore>
<topic></topic>
<that></that>
<template></template>
<word word="word"></word>
<set name="SETNAME">
</set><bot property="botname">
</bot><iset words="WORD1 WORD2"></iset>
<regex pattern="^LEGION$"></regex>
<regex template="LEGION"></regex>
"""
generated_xml = node.to_xml(self._client_context)
self.assertEqual(generated_xml, test_result)
def __init__(self, userid='*'):
PatternNode.__init__(self, userid)
def test_init(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertEquals(0, len(node.priority_words))
self.assertFalse(node.has_priority_words())
self.assertFalse(node.is_priority())
self.assertIsNone(node.arrow)
self.assertIsNone(node.hash)
self.assertIsNone(node.underline)
self.assertIsNone(node.star)
self.assertFalse(node.has_wildcard())
self.assertFalse(node.has_zero_or_more())
self.assertFalse(node.has_0ormore_arrow())
self.assertFalse(node.has_0ormore_hash())
self.assertFalse(node.has_one_or_more())
self.assertFalse(node.has_1ormore_star())
self.assertFalse(node.has_1ormore_underline())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertEquals(0, len(node.children))
self.assertFalse(node.has_children())
self.assertFalse(node.has_nodes())
self.assertIsNone(node.topic)
self.assertFalse(node.is_topic())
self.assertFalse(node.has_topic())
self.assertIsNone(node.that)
self.assertFalse(node.is_that())
self.assertFalse(node.has_that())
self.assertIsNone(node.template)
self.assertFalse(node.is_template())
self.assertFalse(node.has_template())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertEquals("P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)", node._child_count(verbose=True))
self.assertEquals("", node._child_count(verbose=False))
self.assertEquals("NODE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]", node.to_string(verbose=True))
self.assertEquals("NODE", node.to_string(verbose=False))
self.assertEquals("", node.to_xml(self._client_context))
self.assertEquals("", node.to_xml(self._client_context))
