def test_global_get(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = False
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
conversation.set_property("name", "keith")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
def test_resolve_no_defaults_inside_topic(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateTopicStarNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
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._conversations["testid"] = conversation
self.assertEqual("Matched", node.resolve(self._client_context))
def parse_bot_expression(self, expression, branch):
bot_node = TemplateBotNode()
branch.children.append(bot_node)
name_found = False
if 'name' in expression.attrib:
node = TemplateNode()
name_node = TemplateWordNode(expression.attrib['name'])
node.append(name_node)
name_found = True
bot_node.name = node
self.parse_text(self.get_text_from_element(expression), bot_node)
for child in expression:
if child.tag == 'name':
node = TemplateNode()
self.parse_text(self.get_text_from_element(child), node)
for sub_child in child:
self.parse_tag_expression(sub_child, node)
self.parse_text(self.get_text_from_element(child), node)
bot_node.name = node
name_found = True
else:
self.parse_tag_expression(child, bot_node)
self.parse_text(self.get_tail_from_element(child), bot_node)
if name_found is False:
raise ParserException("Error, name not found", xml_element=expression)
def test_node_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType2ConditionNode("var1", local=True)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(value=TemplateWordNode("value1"))
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(value=TemplateWordNode("value2"))
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode()
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
question = Question.create_from_text("Hello")
self.bot.conversation(self.clientid).record_dialog(question)
self.bot.conversation(self.clientid).current_question().set_predicate("var1", "value2")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def test_xml_tree_simple(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateWordNode("Word2"))
xml = node.xml_tree(self._client_context)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template>Word1 Word2</template>", xml_str)
def test_local_set(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", question.predicate("name"))
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation("testid", self.bot)
question = Question.create_from_text("Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text("Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self.bot._conversations["testid"] = conversation
response = root.resolve(self.bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType3ConditionNode()
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(name="name1", value=TemplateWordNode("value1") )
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(name="name2", value=TemplateWordNode("value1"), local=True )
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(name="name3")
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
self.bot.conversation(self.clientid)._predicates['name1'] = "value1"
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("Word1", result)
def test_global_set_allow_overrides_with_default(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
self.bot._configuration.override_predicates = True
self.bot.brain.properties.pairs.append(["name", "fred"])
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.local = False
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", conversation.predicate("name"))
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.index)
conversation = Conversation(self._client_context)
self._client_context.bot._conversations["testid"] = conversation
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "What did you say")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
def test_resolve_no_sentence(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRequestNode(index=3)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(3, node.index)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you. Are you well")
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "")
def test_nestedrandom(self):
root = TemplateNode()
self.assertIsNotNone(root)
random1 = TemplateRandomNode()
random1.append(TemplateWordNode("Test1"))
random1.append(TemplateWordNode("Test2"))
self.assertEqual(len(random1.children), 2)
random2 = TemplateRandomNode()
random2.append(TemplateWordNode("Test3"))
random2.append(TemplateWordNode("Test4"))
self.assertEqual(len(random1.children), 2)
random3 = TemplateRandomNode()
random3.append(random1)
random3.append(random1)
random3.append(random2)
root.append(random3)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertOneOf(resolved, ["Test1",
"Test2",
"Test3",
"Test4"])
def test_carousel_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
carousel = TemplateCarouselNode()
card = TemplateCardNode()
card._image = TemplateWordNode("http://Servusai.com")
card._title = TemplateWordNode("Servusai.com")
card._subtitle = TemplateWordNode("The home of ProgramY")
button = TemplateButtonNode()
button._text = TemplateWordNode("More...")
button._url = TemplateWordNode("http://Servusai.com/aiml")
card._buttons.append(button)
carousel._cards.append(card)
root.append(carousel)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEquals("<carousel><card><image>http://Servusai.com</image><title>Servusai.com</title><subtitle>The home of ProgramY</subtitle><button><text>More...</text><url>http://Servusai.com/aiml</url></button></card></carousel>", resolved)
self.assertEquals("<carousel><card><image>http://Servusai.com</image><title>Servusai.com</title><subtitle>The home of ProgramY</subtitle><button><text>More...</text><url>http://Servusai.com/aiml</url></button></card></carousel>", root.to_xml(self._client_context))
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateThatNode(question=1, sentence=1)
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(1, node.question)
self.assertEqual(1, node.sentence)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("Hello matey", node.resolve(self._client_context))
def test_resolve_with_no_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode(index=1)
self.assertIsNotNone(node)
self.assertEqual(1, node.index)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
def test_local_no_value(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property("default-get", "unknown")
conversation = self._client_context.bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello")
conversation.record_dialog(question)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_node_exception_handling(self):
root = TemplateNode()
node = MockTemplateSentenceNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_node_exception_handling(self):
root = TemplateNode()
node = MockTemplateDeleteTripleNode(TemplateWordNode("S"), TemplateWordNode("P"), TemplateWordNode("O"))
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_to_xml(self):
root = TemplateNode()
root.append(TemplateIdNode())
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><id /></template>", xml_str)
def test_node(self):
root = TemplateNode()
node = TemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_to_xml(self):
root = TemplateNode()
root.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template>Hello</template>", xml_str)
def test_node_defaults(self):
root = TemplateNode()
node = TemplateUniqNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_to_xml_no_default_star(self):
root = TemplateNode()
node = TemplateThatNode(question=3, sentence=-1)
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><that index="3,*" /></template>', xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateResponseNode()
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><response /></template>", xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateResponseNode(position=2, index=3)
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><response index="3" position="2" /></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><addtriple><subj>S</subj><pred>P</pred><obj>O</obj></addtriple></template>", xml_str)
def test_to_xml_composite(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateIdNode())
srai = TemplateSRAINode()
srai.append(TemplateWordNode("Srai1"))
node.append(srai)
node.append(TemplateWordNode("Word2"))
self.assertEqual("Word1 <id /> <srai>Srai1</srai> Word2", node.to_xml(self._client_context))
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateRequestNode(index=3)
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><request index="3" /></template>', xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateDateNode()
root.append(node)
node.append(TemplateWordNode("Mon Sep 30 07:06:05 2013"))
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><date format="%c">Mon Sep 30 07:06:05 2013</date></template>', xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateThatNode()
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><that /></template>", xml_str)
def test_node_saerver_mode(self):
root = TemplateNode()
self.assertIsNotNone(root)
error_log = TemplateLogNode()
self.assertIsNotNone(error_log)
error_log.level = "error"
error_log.append(TemplateWordNode("Error Log"))
warnig_log = TemplateLogNode()
self.assertIsNotNone(warnig_log)
warnig_log.level = "warnig"
warnig_log.append(TemplateWordNode("Warnig Log"))
info_log = TemplateLogNode()
self.assertIsNotNone(info_log)
info_log.level = "info"
info_log.append(TemplateWordNode("Info log"))
debug_log = TemplateLogNode()
self.assertIsNotNone(debug_log)
debug_log.level = "debug"
debug_log.append(TemplateWordNode("Debug Log"))
root.append(error_log)
root.append(warnig_log)
root.append(info_log)
root.append(debug_log)
self.assertEqual(4, len(root.children))
self._client_context._server_mode = True
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual("", resolved)
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertEqual(4, len(conversation.logs))
def __init__(self):
TemplateNode.__init__(self)
self._image = None
self._title = None
self._subtitle = None
self._buttons = []
def __init__(self):
TemplateNode.__init__(self)
self._pattern = None
self._topic = None
self._that = None
self._template = None
def __init__(self):
TemplateNode.__init__(self)
self._items = []
def __init__(self):
TemplateNode.__init__(self)
self._path = None
def __init__(self):
TemplateNode.__init__(self)
self._cards = []
def __init__(self):
TemplateNode.__init__(self)
self._name = None
self._local = False
def __init__(self, name=None, value=None):
TemplateNode.__init__(self)
self._name = name
def test_node_no_conversation(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
self.assertEqual("", root.resolve(self._client_context))
def __init__(self):
TemplateNode.__init__(self)
self._interval_format = None
self._style = None
self._interval_from = None
self._interval_to = None
def __init__(self):
TemplateNode.__init__(self)
self._name = None
def __init__(self):
TemplateNode.__init__(self)
def __init__(self):
TemplateNode.__init__(self)
self._seconds = None
def __init__(self, node_name, subj=None, pred=None, obj=None):
TemplateNode.__init__(self)
self._node_name = node_name
self._subj = subj
self._pred = pred
self._obj = obj
def __init__(self, name=None, value=None, var_type=GLOBAL, loop=False):
TemplateNode.__init__(self)
self._name = name
self._value = value
self._var_type = var_type
self._loop = loop
def test_node_invalid_class(self):
root = TemplateNode()
node = TemplateExtensionNode()
node.path = "test.parser.template.node_tests.test_extension.MockExtensionOther"
root.append(node)
self.assertEqual(root.resolve(self.bot, self.clientid), "")
def __init__(self):
TemplateNode.__init__(self)
self._text = None
self._url = None
self._postback = None
def __init__(self):
TemplateNode.__init__(self)
self._role = None
self._denied_srai = None
def __init__(self, query=None):
TemplateNode.__init__(self)
if query is None:
self._query = RDFSelectStatement()
else:
self._query = query
def __init__(self, word):
TemplateNode.__init__(self)
self._word = word
def __init__(self):
TemplateNode.__init__(self)
self._name = None
# TODO Load this from configuration file
self._internal_maps = [PluralMap(), SingularMap(), PredecessorMap(), SuccessorMap()]
def __init__(self):
TemplateNode.__init__(self)
self._service = None
