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_tuples_string(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
select = TemplateWordNode("Hello")
self.assertIsNotNone(select)
node = TemplateGetNode()
node.name = TemplateWordNode("?x ?y")
node.tuples = select
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual("[GET [Tuples] - ([WORD]?x ?y)]", node.to_string())
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><get var="?x ?y">Hello</get></template>',
xml_str)
result = root.resolve_to_string(self._client_context)
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 get_condition_variable_value(self, client_context, var_type, name):
if var_type == TemplateConditionVariable.GLOBAL:
return TemplateGetNode.get_property_value(client_context, False, name)
elif var_type == TemplateConditionVariable.LOCAL:
return TemplateGetNode.get_property_value(client_context, True, name)
elif var_type == TemplateConditionVariable.BOT:
return TemplateBotNode.get_bot_variable(client_context, name)
else:
return"unknown"
def test_to_xml_global_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = False
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><get name="name" /></template>', xml_str)
def test_to_xml_local_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
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><get var="name" /></template>', xml_str)
def get_condition_variable_value(self, client_context, var_type, name):
if var_type == TemplateConditionVariable.GLOBAL:
return TemplateGetNode.get_property_value(client_context, False,
name)
elif var_type == TemplateConditionVariable.LOCAL:
return TemplateGetNode.get_property_value(client_context, True,
name)
elif var_type == TemplateConditionVariable.BOT:
return TemplateBotNode.get_bot_variable(client_context, name)
else:
return "unknown"
def test_to_xml_local_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
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><get var="name" /></template>', xml_str)
def test_to_xml_typedata_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.property_type = "data"
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><get data="name" /></template>', xml_str)
def parse_get_expression(self, expression, branch):
get_node = TemplateGetNode()
branch.children.append(get_node)
name_found = False
var_found = False
if 'name' in expression.attrib:
node = TemplateNode()
name_node = TemplateWordNode(expression.attrib['name'])
node.append(name_node)
get_node.local = False
name_found = True
get_node.name = node
if 'var' in expression.attrib:
node = TemplateNode()
var_node = TemplateWordNode(expression.attrib['var'])
node.append(var_node)
get_node.local = True
var_found = True
get_node.name = 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)
get_node.name = node
get_node.local = False
name_found = True
elif child.tag == 'var':
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)
get_node.name = node
get_node.local = True
var_found = True
else:
raise ParserException("Error, invalid get", xml_element=expression)
if name_found is True and var_found is True:
raise ParserException("Error, get node has both name AND var values", xml_element=expression)
def resolve_to_string(self, client_context):
conversation = client_context.bot.get_conversation(client_context)
name = self.name.resolve(client_context)
value = self.resolve_children(client_context)
if self.property_type == 'var':
YLogger.debug(client_context, "[%s] resolved to var: [%s] => [%s]",
self.to_string(), name, value)
conversation.current_question().set_property(name, value)
elif self.property_type == 'data':
YLogger.debug(client_context,
"[%s] resolved to data: [%s] => [%s]",
self.to_string(), name, value)
conversation.set_data_property(name, value)
elif self.property_type == 'name':
YLogger.debug(client_context,
"[%s] resolved to name: [%s] => [%s]",
self.to_string(), name, value)
value = conversation.set_property(name, value)
YLogger.debug(client_context, "[%s] resolved to [%s]",
self.to_string(), value)
if value == '':
value = TemplateGetNode.get_default_value(client_context)
return value
def execute(self, client_context, data):
YLogger.debug(client_context, "Properties Admin - [%s]", data)
properties = ""
splits = data.split()
if splits[0] == 'GET':
if splits[1] == 'BOT':
properties = TemplateBotNode.get_bot_variable(
client_context, splits[2])
elif splits[1] == "USER":
if splits[2].upper() == 'NAME':
properties = TemplateGetNode.get_property_value(
client_context, 'name', splits[3])
elif splits[2].upper() == 'DATA':
properties = TemplateGetNode.get_property_value(
client_context, 'data', splits[3])
elif splits[2].upper() == 'VAR':
properties = TemplateGetNode.get_property_value(
client_context, 'var', splits[3])
elif splits[0] == 'BOT':
properties += "Properties:<br /><ul>"
for pair in client_context.brain.properties.pairs:
properties += "<li>%s = %s</li>" % (pair[0], pair[1])
properties += "</ul>"
properties += "<br />"
elif splits[0] == "USER":
if client_context.bot.has_conversation(client_context):
conversation = client_context.bot.get_conversation(
client_context)
properties += "Properties:<br /><ul>"
for name, value in conversation.properties.items():
properties += "<li>%s = %s</li>" % (name, value)
properties += "</ul>"
properties += "<br />"
else:
properties += "No conversation currently available"
return properties
def test_global_no_name(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [Global] - None]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property("default-get", "unknown")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("", result)
def test_global_no_name(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [Global] - None]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self.bot.brain.properties.add_property("default-get", "unknown")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("", result)
def test_typevar_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.property_type = "var"
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, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
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.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
conversation.set_property("name", "keith")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
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.bot.brain.properties.add_property("default-get", "unknown")
conversation = self.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_typevar_get(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.property_type = "var"
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, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
question.set_property("name", "keith")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
def test_tuples(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
select = TemplateSelectNode()
self.assertIsNotNone(select)
node = TemplateGetNode()
node.name = TemplateWordNode("?x ?y")
node.tuples = select
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual("[GET [Tuples] - ([WORD]?x ?y)]", node.to_string())
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><get var="?x ?y"><select><vars /></select></get></template>', xml_str)
def test_tuples(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
select = TemplateSelectNode()
self.assertIsNotNone(select)
node = TemplateGetNode()
node.name = TemplateWordNode("?x ?y")
node.tuples = select
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual("[GET [Tuples] - ([WORD]?x ?y)]", node.to_string())
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><get var="?x ?y"><select /></get></template>', xml_str)
def resolve_to_string(self, client_context):
result = self.resolve_children_to_string(client_context)
resolved = TemplateGetNode.get_default_value(client_context)
if result != "":
try:
data = json.loads(result)
if isinstance(data, list):
if len(data) > 0:
resolved = json.dumps(data[0])
else:
raise Exception("Not what I wanted")
except Exception:
words = client_context.brain.tokenizer.texts_to_words(result)
if len(words) > 0:
resolved = words[0]
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
return resolved
def test_global_get_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 = False
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [Global] - [WORD]name]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property("default-get", "unknown")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_unknown_from_config(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.property_type = "name"
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [name] - [WORD]name]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.bot.brain.configuration.defaults._default_get = None
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def execute(self, bot, clientid, data):
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("Properties Admin - [%s]", data)
properties = ""
splits = data.split()
if splits[0] == 'GET':
if splits[1] == 'BOT':
properties = TemplateBotNode.get_bot_variable(bot, clientid, splits[2])
elif splits[1] == "USER":
local = bool(splits[2].upper == 'LOCAL')
properties = TemplateGetNode.get_property_value(bot, clientid, local, splits[3])
elif splits[0] == 'BOT':
properties += "Properties:<br /><ul>"
for pair in bot.brain.properties.pairs:
properties += "<li>%s = %s</li>"%(pair[0], pair[1])
properties += "</ul>"
properties += "<br />"
elif splits[0] == "USER":
if bot.has_conversation(clientid):
conversation = bot.conversation(clientid)
properties += "Properties:<br /><ul>"
for name, value in conversation.properties.items():
properties += "<li>%s = %s</li>"%(name, value)
properties += "</ul>"
properties += "<br />"
else:
properties += "No conversation currently available"
return properties
def execute(self, client_context, data):
YLogger.debug(client_context, "Properties Admin - [%s]", data)
properties = ""
splits = data.split()
if splits[0] == 'GET':
if splits[1] == 'BOT':
properties = TemplateBotNode.get_bot_variable(client_context, splits[2])
elif splits[1] == "USER":
local = bool(splits[2].upper == 'LOCAL')
properties = TemplateGetNode.get_property_value(client_context, local, splits[3])
elif splits[0] == 'BOT':
properties += "Properties:<br /><ul>"
for pair in client_context.brain.properties.pairs:
properties += "<li>%s = %s</li>"%(pair[0], pair[1])
properties += "</ul>"
properties += "<br />"
elif splits[0] == "USER":
if client_context.bot.has_conversation(client_context):
conversation = client_context.bot.conversation(client_context)
properties += "Properties:<br /><ul>"
for name, value in conversation.properties.items():
properties += "<li>%s = %s</li>"%(name, value)
properties += "</ul>"
properties += "<br />"
else:
properties += "No conversation currently available"
return properties
def test_global_get_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 = False
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.bot.brain.properties.add_property("default-get", "unknown")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_typename_no_name(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.append(TemplateWordNode("Fred"))
node.property_type = "name"
self.assertIsNotNone(node)
self.assertEqual("[GET [name] - None]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property(
"default-get", "unknown")
with self.assertRaises(Exception):
root.resolve(self._client_context)
def resolve_to_string(self, client_context):
resolved = ""
conversation = client_context.bot.get_conversation(client_context)
slotName = self._slotName.resolve(client_context)
itemName = self._itemName.resolve(client_context)
try:
slotIndex = int(self._index.resolve(client_context))
except Exception:
slotIndex = 0
slots = None
try:
value = conversation.current_question().property(
"__SYSTEM_NLUDATA__")
json_dict = json.loads(value)
slots = json_dict["slots"]
except Exception:
YLogger.error(
self, "TemplateNluSlotNode failed to load __SYSTEM_NLUDATA__")
return resolved
slotsKeyName = "slot"
slotKeys = [slot.get(slotsKeyName) for slot in slots]
if itemName == "count":
if slotName == "*":
resolved = str(len(slotKeys))
else:
resolved = str(slotKeys.count(slotName))
YLogger.debug(client_context, "nluslot [%s] resolved to [%s]",
itemName, resolved)
return resolved
index = None
try:
if slotName == "*":
index = 0
if slotIndex != 0:
index = slotIndex
else:
if slotIndex != 0:
slotCounter = 0
targetCounter = 0
for name in slotKeys:
if name == slotName:
if targetCounter == slotIndex:
index = slotCounter
break
targetCounter += 1
slotCounter += 1
else:
index = slotKeys.index(slotName)
except Exception:
YLogger.debug(client_context, "nluslot non search keys:%s",
slotName)
if index is not None:
YLogger.debug(client_context, "nluintent index[%s]", index)
try:
if itemName in slots[index]:
resolved = str(slots[index].get(itemName))
except Exception:
YLogger.debug(client_context, "nluslot non search item:%s",
itemName)
if resolved == '':
YLogger.debug(client_context, "nluslot failed slot=[%s] item=[%s]",
slotName, itemName)
resolved = TemplateGetNode.get_default_value(client_context)
YLogger.debug(client_context, "nluslot [%s] resolved to [%s:%s]",
slotName, itemName, resolved)
return resolved
def resolve_to_string(self, client_context):
resolved = ""
conversation = client_context.bot.get_conversation(client_context)
intentName = self._intentName.resolve(client_context)
itemName = self._itemName.resolve(client_context)
try:
intentIndex = int(self._index.resolve(client_context))
except Exception:
intentIndex = 0
intents = None
try:
value = conversation.current_question().property("__SYSTEM_NLUDATA__")
json_dict = json.loads(value)
intents = json_dict["intents"]
except Exception:
YLogger.error(self, "TemplateNluintentNode failed to load __SYSTEM_NLUDATA__")
return resolved
intentsKeyName = "intent"
intentsKey = [intent.get(intentsKeyName) for intent in intents]
if itemName == "count":
if intentName == "*":
resolved = str(len(intentsKey))
else:
resolved = str(intentsKey.count(intentName))
YLogger.debug(client_context, "nluintent [%s] resolved to [%s]", itemName, resolved)
return resolved
index = None
try:
if intentName == "*":
index = 0
if intentIndex != 0:
index = intentIndex
else:
if intentIndex != 0:
intentCounter = 0
counter = 0
for name in intentsKey:
if name == intentName:
if counter == intentIndex:
index = intentCounter
counter += 1
intentCounter += 1
else:
index = intentsKey.index(intentName)
except Exception:
YLogger.debug(client_context, "nluintent non search keys:%s", intentName)
if index is not None:
YLogger.debug(client_context, "nluintent index[%s]", index)
try:
if itemName in intents[index]:
resolved = str(intents[index].get(itemName))
except Exception:
YLogger.debug(client_context, "nluintent non search item:%s", itemName)
if resolved == '':
YLogger.debug(client_context, "nluintent failed intent=[%s] item=[%s]", intentName, itemName)
resolved = TemplateGetNode.get_default_value(client_context)
YLogger.debug(client_context, "nluintent [%s] resolved to [%s:%s]", intentName, itemName, resolved)
return resolved
def test_get_tuples_invalid_json(self):
node = TemplateGetNode()
node.tuples = TemplateWordNode('"1", "2", "3"')
self.assertEquals([], node._get_tuples(self._client_context))
def test_default_value_properties(self):
self._client_context.bot.brain.properties.add_property(
"default_get", "test123")
self.assertEqual(
"test123", TemplateGetNode.get_default_value(self._client_context))
def __init__(self):
TemplateGetNode.__init__(self)
def resolve_to_string(self, client_context):
resolved = ""
conversation = client_context.bot.get_conversation(client_context)
slotName = self._slotName.resolve(client_context)
itemName = self._itemName.resolve(client_context)
try:
slotIndex = int(self._index.resolve(client_context))
except Exception:
slotIndex = 0
try:
if self._varName is None:
value = conversation.current_question().property(
"__SYSTEM_NLUDATA__")
if value is None:
YLogger.error(
self, "TemplateNluSlotNode __SYSTEM_NLUDATA__ is None")
resolved = TemplateGetNode.get_default_value(
client_context)
return resolved
else:
if self._varType == 'name':
value = conversation.property(self._varName)
elif self._varType == 'data':
value = conversation.data_property(self._varName)
else:
value = conversation.current_question().property(
self._varName)
if value is None:
YLogger.error(
self, "TemplateNluSlotNode %s is None" % self._varName)
resolved = TemplateGetNode.get_default_value(
client_context)
return resolved
except Exception:
YLogger.error(self,
"TemplateNluSlotNode failed to load NLU result")
resolved = TemplateGetNode.get_default_value(client_context)
return resolved
slots = None
try:
json_dict = json.loads(value)
if self._keys is not None:
first = True
for key in self._keys:
if first:
first = False
continue
json_dict = json_dict[key]
if key == self._keys[-1]:
break
slots = json_dict["slots"]
except Exception:
YLogger.error(
self, "TemplateNluSlotNode slots not found in target data")
resolved = TemplateGetNode.get_default_value(client_context)
return resolved
slotsKeyName = "slot"
slotKeys = [slot.get(slotsKeyName) for slot in slots]
if itemName == "count":
if slotName == "*":
resolved = str(len(slotKeys))
else:
resolved = str(slotKeys.count(slotName))
YLogger.debug(client_context, "nluslot [%s] resolved to [%s]",
itemName, resolved)
return resolved
index = None
try:
if slotName == "*":
index = 0
if slotIndex != 0:
index = slotIndex
else:
if slotIndex != 0:
slotCounter = 0
targetCounter = 0
for name in slotKeys:
if name == slotName:
if targetCounter == slotIndex:
index = slotCounter
break
targetCounter += 1
slotCounter += 1
else:
index = slotKeys.index(slotName)
except Exception:
YLogger.debug(client_context, "nluslot non search keys:%s",
slotName)
if index is not None:
YLogger.debug(client_context, "nluintent index[%s]", index)
try:
if itemName in slots[index]:
resolved = str(slots[index].get(itemName))
except Exception:
YLogger.debug(client_context, "nluslot non search item:%s",
itemName)
if resolved == '':
YLogger.debug(client_context, "nluslot failed slot=[%s] item=[%s]",
slotName, itemName)
resolved = TemplateGetNode.get_default_value(client_context)
YLogger.debug(client_context, "nluslot [%s] resolved to [%s:%s]",
slotName, itemName, resolved)
return resolved
def resolve_to_string(self, client_context):
resolved = self.resolve_children(client_context)
resolved = resolved.strip()
conversation = client_context.bot.get_conversation(client_context)
name = self._name.resolve(client_context)
try:
key = self._key.resolve(client_context)
name = name + "." + key
except Exception:
pass
try:
self.function = self._function.resolve(client_context)
if self.function not in ['len', 'delete', 'insert']:
YLogger.debug(self, "JSON unknown function type [%s]",
self.function)
return ''
except Exception:
self.function = 'None'
try:
self.index = self._index.resolve(client_context)
try:
int(self.index)
except ValueError:
YLogger.debug("JSON index not numeric [%s]", self.index)
except Exception:
self.index = ""
try:
self.item = self._item.resolve(client_context)
except Exception:
self.item = "value"
if self.function == 'insert' and self.index == "":
YLogger.debug(self, "JSON insert-function needs index parameter")
return ''
if self.function == 'delete':
resolved = ''
try:
self.keys = name.split('.')
if '' in self.keys:
YLogger.debug(self, "JSON invalid key")
if len(resolved) == 0 and self.function != 'delete':
return TemplateGetNode.get_default_value(client_context)
else:
return ''
if self._type == "var":
if conversation.has_current_question():
value = conversation.current_question().property(
self.keys[0])
elif self._type == "data":
value = conversation.data_property(self.keys[0])
elif self._type == "name":
value = conversation.property(self.keys[0])
else:
YLogger.debug(self, "JSON invalid variables type")
return ''
json_dict = json.loads(value)
except Exception:
if len(resolved) == 0:
json_dict = None
else:
json_dict = {}
if len(resolved) > 0:
resolved = self._json_set_elements(client_context, json_dict,
resolved)
else:
if self.function == 'delete':
resolved = self._json_delete_elements(client_context,
json_dict)
else:
resolved = self._json_get_elements(client_context, json_dict)
return resolved
def _json_get_elements(self, client_context, json_dict):
if self.index != "":
try:
indexNo = int(self.index)
except Exception:
resolved = TemplateGetNode.get_default_value(client_context)
YLogger.debug(
client_context,
"Template-JSON failed to get (invalid index[%s])",
self.index)
return resolved
resolved = ''
if json_dict is not None:
try:
first = True
for key in self.keys:
if first:
first = False
continue
json_dict = json_dict[key]
if type(json_dict) is dict or type(json_dict) is list:
dic_len = len(json_dict)
if self.function == 'len':
resolved = str(dic_len)
elif self.index != "":
if indexNo < 0:
indexNo += dic_len
if indexNo < 0:
indexNo = dic_len
if indexNo < dic_len:
if type(json_dict) is dict:
for loop, indexKey in enumerate(json_dict):
if loop == indexNo:
if self.item == 'key':
resolved = indexKey
else:
resolved = json_dict[indexKey]
break
else:
resolved = json_dict[indexNo]
if resolved is None:
resolved = 'null'
else:
resolved = json_dict
else:
if self.function == 'len':
resolved = "1"
else:
if self.index != "":
if indexNo == 0 or indexNo == -1:
resolved = json_dict
else:
resolved = ''
else:
if json_dict is None:
resolved = 'null'
else:
if type(json_dict) is str and len(
json_dict) == 0:
resolved = '""'
else:
resolved = json_dict
if type(resolved) is dict or type(resolved) is list:
resolved = json.dumps(resolved, ensure_ascii=False)
elif type(resolved) is int or type(resolved) is float or type(
resolved) is complex:
resolved = str(resolved)
elif type(resolved) is bool:
resolved = str(resolved).lower()
except Exception as e:
YLogger.exception(self, "JSON failed to load JSON", e)
if resolved == '':
YLogger.debug(client_context,
"TemplateJsonNode get failed %s index=[%s]",
self.keys, self.index)
resolved = TemplateGetNode.get_default_value(client_context)
YLogger.debug(client_context, "JSON get %s resolved to [%s]",
self.keys, resolved)
return resolved
def test_default_value_default_get(self):
self._client_context.bot.brain.configuration.defaults._default_get = "test456"
self.assertEqual(
"test456", TemplateGetNode.get_default_value(self._client_context))
def test_default_value_no_value(self):
self._client_context.bot.brain.configuration.defaults._default_get = None
self.assertEqual(
"unknown", TemplateGetNode.get_default_value(self._client_context))
def __init__(self):
TemplateGetNode.__init__(self)
def execute(self, client_context, data):
YLogger.debug(client_context, "Properties Admin - [%s]", data)
properties = ""
splits = data.split()
command = splits[0]
if command == 'GET':
get_command = splits[1]
if get_command == 'BOT':
if len(splits) == 3:
var_name = splits[2]
properties = TemplateBotNode.get_bot_variable(
client_context, var_name)
else:
return "Missing variable name for GET BOT"
elif get_command == "USER":
if len(splits) < 3:
return "Invalid syntax for GET USER, LOCAL or GLOBAL"
var_type = splits[2].upper()
if var_type not in ['LOCAL', 'GLOBAL']:
return "Invalid GET USER var type [%s]" % var_type
if len(splits) < 4:
return "Missing variable name for GET USER"
var_name = splits[3]
if var_type == 'LOCAL':
properties = TemplateGetNode.get_property_value(
client_context, True, var_name)
else:
properties = TemplateGetNode.get_property_value(
client_context, False, var_name)
else:
return "Unknown GET command [%s]" % get_command
elif command == 'BOT':
properties += "Properties:<br /><ul>"
for pair in client_context.brain.properties.pairs:
properties += "<li>%s = %s</li>" % (pair[0], pair[1])
properties += "</ul>"
properties += "<br />"
elif command == "USER":
if client_context.bot.has_conversation(client_context):
conversation = client_context.bot.get_conversation(
client_context)
properties += "Properties:<br /><ul>"
for name, value in conversation.properties.items():
properties += "<li>%s = %s</li>" % (name, value)
properties += "</ul>"
properties += "<br />"
else:
properties += "No conversation currently available"
else:
return "Unknown properties command [%s]" % command
return properties
