def test_not_match_vars_subject_predicate_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.not_match_to_vars("?x", "?y", "?z") self.assertIsNotNone(matched) self.assertEquals(0, len(matched))
def test_not_match_vars_subject(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) not_matched = collection.not_match_to_vars("?x") self.assertIsNotNone(not_matched) self.assertEquals(0, len(not_matched))
def test_not_match_vars(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.not_match_to_vars() self.assertIsNotNone(matched) self.assertEquals(0, len(matched))
def test_match_as_tuples_subject_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.matched_as_tuples(subject="MONKEY", obj="2") self.assertIsNotNone(matched) self.assertEquals(1, len(matched)) self.assertTrue(["MONKEY", "LEGS", "2"] in matched)
def test_unify_multi_var_deep(self): collection = RDFCollection() self.assertIsNotNone(collection) collection.add_entity("TEST1", "ISA", "TEST2") collection.add_entity("TEST2", "ISA", "TEST3") collection.add_entity("TEST3", "ISA", "TEST4") collection.add_entity("TEST4", "ISA", "TEST5") set1 = collection.match_to_vars("?x", "ISA", "?y") set2 = collection.match_to_vars("?y", "ISA", "?z") set3 = collection.match_to_vars("?z", "ISA", "?w") unified = collection.unify(("?x", "?y", "?z", "?w"), [set1, set2, set3]) self.assertIsNotNone(unified) self.assertEquals(2, len(unified)) self.assertTrue([ ['?x', 'TEST1'], ['?y', 'TEST2'], ['?z', 'TEST3'], ['?w', 'TEST4'], ] in unified) self.assertTrue([['?x', 'TEST2'], ['?y', 'TEST3'], ['?z', 'TEST4'], ['?w', 'TEST5']] in unified)
def test_match_all_as_tuples_predicate_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.matched_as_tuples(predicate="LEGS", obj="2") self.assertIsNotNone(matched) self.assertEquals(2, len(matched)) self.assertTrue(["MONKEY", "LEGS", "2"] in matched) self.assertTrue(["BIRD", "LEGS", "2"] in matched)
def match_only_vars(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.match_only_vars(subject="MONKEY", obj="?x") self.assertIsNotNone(matched) self.assertEquals(2, len(matched)) self.assertTrue([['?x', '2']] in matched) self.assertTrue([['?x', 'true']] in matched)
def test_not_match_vars_subject_with_predicate_params(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) not_matched = collection.not_match_to_vars(subject="?x", predicate="LEGS") self.assertIsNotNone(not_matched) self.assertEquals(1, len(not_matched)) self.assertTrue([['?x', 'ELEPHANT'], ['pred', 'TRUNK'], ['obj', 'true']] in not_matched)
def test_delete_collection_subject_predicate(self): collection = RDFCollection() self.assertIsNotNone(collection) collection.add_entity("ACCOUNT", "hasSize", "0") self.assertTrue(collection.has_subject('ACCOUNT')) self.assertTrue(collection.has_predicate('ACCOUNT', 'hasSize')) self.assertTrue(collection.has_object('ACCOUNT', 'hasSize', "0")) collection.delete_entity("ACCOUNT", "hasSize") self.assertFalse(collection.has_subject('ACCOUNT'))
def test_match_vars_object_with_subject_predicate_params(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.match_to_vars(subject="MONKEY", predicate="LEGS", obj="?x") self.assertIsNotNone(matched) self.assertEqual(1, len(matched)) self.assertTrue( [['subj', 'MONKEY'], ['pred', 'LEGS'], ['?x', '2']] in matched)
def test_match_vars_subject_predicate_with_subject_params(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.match_to_vars(subject="MONKEY", predicate="?y") self.assertIsNotNone(matched) self.assertEquals(2, len(matched)) self.assertTrue( [['subj', 'MONKEY'], ['?y', 'LEGS'], ['obj', '2']] in matched) self.assertTrue( [['subj', 'MONKEY'], ['?y', 'HASFUR'], ['obj', 'true']] in matched)
def test_match_all_as_tuples(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.matched_as_tuples() self.assertIsNotNone(matched) self.assertEquals(5, len(matched)) self.assertTrue(["MONKEY", "LEGS", "2"] in matched) self.assertTrue(["MONKEY", "HASFUR", "true"] in matched) self.assertTrue(["ZEBRA", "LEGS", "4"] in matched) self.assertTrue(["BIRD", "LEGS", "2"] in matched) self.assertTrue(["ELEPHANT", "TRUNK", "true"] in matched)
def test_remove_predicate(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) all = collection.all_as_tuples() remains = collection.remove(all, predicate='LEGS') self.assertIsNotNone(remains) self.assertEquals(2, len(remains)) self.assertTrue(["MONKEY", "HASFUR", "true"] in remains) self.assertTrue(["ELEPHANT", "TRUNK", "true"] in remains)
def test_remove_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) all = collection.all_as_tuples() remains = collection.remove(all, obj='2') self.assertIsNotNone(remains) self.assertEquals(3, len(remains)) self.assertTrue(["MONKEY", "HASFUR", "true"] in remains) self.assertTrue(["ZEBRA", "LEGS", "4"] in remains) self.assertTrue(["ELEPHANT", "TRUNK", "true"] in remains)
def test_not_match_vars_object_with_subject_params(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.not_match_to_vars(subject="MONKEY", obj="?x") self.assertIsNotNone(matched) self.assertEquals(3, len(matched)) self.assertTrue([['subj', 'ELEPHANT'], ['pred', 'TRUNK'], ['?x', 'true']] in matched) self.assertTrue( [['subj', 'ZEBRA'], ['pred', 'LEGS'], ['?x', '4']] in matched) self.assertTrue( [['subj', 'BIRD'], ['pred', 'LEGS'], ['?x', '2']] in matched)
def test_remove_subject_predicate(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) all = collection.all_as_tuples() remains = collection.remove(all, subject='MONKEY', predicate="LEGS") self.assertIsNotNone(remains) self.assertEquals(4, len(remains)) self.assertTrue(["MONKEY", "HASFUR", "true"] in remains) self.assertTrue(["ZEBRA", "LEGS", "4"] in remains) self.assertTrue(["BIRD", "LEGS", "2"] in remains) self.assertTrue(["ELEPHANT", "TRUNK", "true"] in remains)
def test_match_vars_predicate_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.match_to_vars(predicate="?x", obj="?y") self.assertIsNotNone(matched) self.assertTrue( [['subj', 'MONKEY'], ['?x', 'LEGS'], ['?y', '2']] in matched) self.assertTrue( [['subj', 'MONKEY'], ['?x', 'HASFUR'], ['?y', 'true']] in matched) self.assertTrue( [['subj', 'ELEPHANT'], ['?x', 'TRUNK'], ['?y', 'true']] in matched) self.assertTrue( [['subj', 'ZEBRA'], ['?x', 'LEGS'], ['?y', '4']] in matched) self.assertTrue( [['subj', 'BIRD'], ['?x', 'LEGS'], ['?y', '2']] in matched)
def test_match_vars_subject_object(self): collection = RDFCollection() self.assertIsNotNone(collection) self.add_data(collection) matched = collection.match_to_vars(subject="?x", obj="?z") self.assertIsNotNone(matched) self.assertEquals(5, len(matched)) self.assertTrue( [['?x', 'MONKEY'], ['pred', 'LEGS'], ['?z', '2']] in matched) self.assertTrue( [['?x', 'MONKEY'], ['pred', 'HASFUR'], ['?z', 'true']] in matched) self.assertTrue( [['?x', 'ELEPHANT'], ['pred', 'TRUNK'], ['?z', 'true']] in matched) self.assertTrue( [['?x', 'ZEBRA'], ['pred', 'LEGS'], ['?z', '4']] in matched) self.assertTrue( [['?x', 'BIRD'], ['pred', 'LEGS'], ['?z', '2']] in matched)
def __init__(self, configuration: BrainConfiguration): #self._bot = bot self._configuration = configuration self.nlp = self.load_nlp() self._aiml_parser = self.load_aiml_parser() self._denormal_collection = DenormalCollection() self._normal_collection = NormalCollection() self._gender_collection = GenderCollection() self._person_collection = PersonCollection() self._person2_collection = PersonCollection() self._rdf_collection = RDFCollection() self._sets_collection = SetCollection() self._maps_collection = MapCollection() self._properties_collection = PropertiesCollection() self._variables_collection = PropertiesCollection() #TODO: Write class for loading client variables from Mongo # self._user_collection = ClientPropertiesCollection() self._preprocessors = ProcessorLoader() self._postprocessors = ProcessorLoader() self._authentication = None self._authorisation = None self._default_oob = None self._oob = {} self._regex_templates = {} self._dynamics_collection = DynamicsCollection() self.load(self.configuration)
def test_collection(self): collection = RDFCollection() self.assertIsNotNone(collection) count = collection.load_from_text(""" ACCOUNT:hasPurpose:to track money ACCOUNT:hasSize:0 ACCOUNT:hasSyllables:2 ACCOUNT:isa:Concept ACCOUNT:lifeArea:Finances ACT:hasPurpose:to entertain by performing """) self.assertEqual(count, 6) self.assertTrue(collection.has_subject('ACCOUNT')) self.assertTrue(collection.has_predicate('ACCOUNT', 'hasSize')) self.assertTrue(collection.has_object('ACCOUNT', 'ISA', 'Concept')) self.assertFalse(collection.has_subject('ACCOUNTX')) self.assertFalse(collection.has_predicate('ACCOUNT', 'hasSizeX')) self.assertFalse(collection.has_object('ACCOUNT', 'isa', 'ConceptX'))
def test_unify_on_multi_vars(self): collection = RDFCollection() self.assertIsNotNone(collection) collection.add_entity("TEST1", "ISA", "TEST2") collection.add_entity("TEST2", "ISA", "TEST3") set1 = collection.match_to_vars("?x", "ISA", "?y") set2 = collection.match_to_vars("?y", "ISA", "?z") unified = collection.unify(("?x", "?y", "?z"), [set1, set2]) self.assertIsNotNone(unified) self.assertEquals(1, len(unified)) self.assertTrue(["?x", "TEST1"] in unified[0]) self.assertTrue(["?y", "TEST2"] in unified[0]) self.assertTrue(["?z", "TEST3"] in unified[0])
class Brain(object): def __init__(self, configuration: BrainConfiguration): #self._bot = bot self._configuration = configuration self.nlp = self.load_nlp() self._aiml_parser = self.load_aiml_parser() self._denormal_collection = DenormalCollection() self._normal_collection = NormalCollection() self._gender_collection = GenderCollection() self._person_collection = PersonCollection() self._person2_collection = PersonCollection() self._rdf_collection = RDFCollection() self._sets_collection = SetCollection() self._maps_collection = MapCollection() self._properties_collection = PropertiesCollection() self._variables_collection = PropertiesCollection() #TODO: Write class for loading client variables from Mongo # self._user_collection = ClientPropertiesCollection() self._preprocessors = ProcessorLoader() self._postprocessors = ProcessorLoader() self._authentication = None self._authorisation = None self._default_oob = None self._oob = {} self._regex_templates = {} self._dynamics_collection = DynamicsCollection() self.load(self.configuration) def ylogger_type(self): return "brain" @property def id(self): return self._configuration.section_name @property def bot(self): return self._bot @property def configuration(self): return self._configuration @property def aiml_parser(self): return self._aiml_parser @property def denormals(self): return self._denormal_collection @property def normals(self): return self._normal_collection @property def genders(self): return self._gender_collection @property def persons(self): return self._person_collection @property def person2s(self): return self._person2_collection @property def rdf(self): return self._rdf_collection @property def sets(self): return self._sets_collection @property def maps(self): return self._maps_collection @property def properties(self): return self._properties_collection @property def variables(self): return self._variables_collection @property def preprocessors(self): return self._preprocessors @property def postprocessors(self): return self._postprocessors @property def authentication(self): return self._authentication @property def authorisation(self): return self._authorisation @property def default_oob(self): return self._default_oob @property def oobs(self): return self._oob @property def regex_templates(self): return self._regex_templates @property def dynamics(self): return self._dynamics_collection # @property # def corenlp(self): # return self._corenlp def load_nlp(self): # print("self.configuration.nlp.classname: {}".format(self.configuration.nlp.classname)) # print("self.configuration: {}".format(self.configuration)) if self.configuration and self.configuration.nlp.classname: nlp = ClassLoader.instantiate_class( self.configuration.nlp.classname) return nlp(self.configuration.nlp) else: #todo change this to handle when it's none return None # def load_corenlp(self,): # if self.configuration: # if self.configuration.nlp.corenlp.classname: # try: # YLogger.info(self, "Loading corenlp from class [%s]", self.configuration.nlp.corenlp.classname) # corenlp = ClassLoader.instantiate_class(self.configuration.nlp.corenlp.classname) # return corenlp(self.configuration.nlp.corenlp) # except Exception as excep: # YLogger.exception(self, "Failed to initiate corenlp", excep) # else: # YLogger.warning(self, "No configuration setting for corenlp") # def load_sentence_segmentation(self): # if self.configuration: # if self.configuration.nlp.sentence_segmentation.classname: # try: # YLogger.info(self, "Loading sentence segmentaion from class [%s]", self.configuration.nlp.sentence_segmentation.classname) # sentence_segmentation = ClassLoader.instantiate_class(self.configuration.nlp.sentence_segmentation.classname) # return sentence_segmentation() # except Exception as excep: # YLogger.exception(self, "Failed to initiate sentence segmentation", excep) # else: # YLogger.warning(self, "No configuration setting found for sentence segmentation") # # # def load_tokenizer(self): # if self.configuration is not None and self.configuration.nlp.tokenizer.classname is not None: # YLogger.info(self, "Loading tokenizer from class [%s]", self.configuration.nlp.tokenizer.classname) # tokenizer_class = ClassLoader.instantiate_class(self.configuration.nlp.tokenizer.classname) # return tokenizer_class() # else: # return Tokenizer(self.configuration.tokenizer.split_chars) def load_aiml_parser(self): return AIMLParser(self) def load_aiml(self, configuration): YLogger.info(self, "Loading aiml source brain") self._aiml_parser.load_aiml(configuration) def reload_aimls(self): YLogger.info(self, "Loading aiml source brain") self._aiml_parser.empty() self._aiml_parser.load_aiml(self.configuration) def load_binary(self, configuration): YLogger.info(self, "Loading binary brain from [%s]", configuration.binaries.binary_filename) try: start = datetime.datetime.now() gc.disable() bin_file = open(configuration.binaries.binary_filename, "rb") self._aiml_parser = pickle.load(bin_file) self._aiml_parser._brain = self gc.enable() bin_file.close() stop = datetime.datetime.now() diff = stop - start YLogger.info(self, "Brain load took a total of %.2f sec", diff.total_seconds()) return False # Tell caller, load succeeded and skip aiml load except Exception as excep: YLogger.exception(self, "Failed to load binary file", excep) if configuration.binaries.load_aiml_on_binary_fail is True: return True # Tell caller, load failed and to load aiml directly else: raise excep def save_binary(self, configuration): YLogger.info(self, "Saving binary brain to [%s]", configuration.binaries.binary_filename) start = datetime.datetime.now() bin_file = open(configuration.binaries.binary_filename, "wb") pickle.dump(self._aiml_parser, bin_file) bin_file.close() stop = datetime.datetime.now() diff = stop - start YLogger.info(self, "Brain save took a total of %.2f sec", diff.total_seconds()) def load(self, configuration: BrainConfiguration): load_aiml = True if self.configuration.binaries.load_binary is True: load_aiml = self.load_binary(configuration) if load_aiml is True: self.load_aiml(configuration) if configuration.binaries.save_binary is True: self.save_binary(configuration) YLogger.info(self, "Loading collections") self.load_collections(configuration) YLogger.info(self, "Loading services") self.load_services(configuration) YLogger.info(self, "Loading security services") self.load_security_services(configuration) YLogger.info(self, "Loading oob processors") self.load_oob_processors(configuration) YLogger.info(self, "Loading regex templates") self.load_regex_templates(configuration) YLogger.info(self, "Loading dynamics sets, maps and vars") self.load_dynamics(configuration) def dump_brain_tree(self): if self.configuration.braintree.file is not None: YLogger.debug(self, "Dumping AIML Graph as tree to [%s]", self._configuration.braintree.file) client_context = self.bot.client.create_client_context("system") self.aiml_parser.pattern_parser.save_braintree( client_context, self.configuration.braintree.file, self.configuration.braintree.content) def _load_denormals(self, configuration): if configuration.files.denormal is not None: self._denormal_collection.empty() total = self._denormal_collection.load_from_filename( configuration.files.denormal) YLogger.info(self, "Loaded a total of %d denormalisations", total) else: YLogger.warning(self, "No configuration setting for denormal") def _load_normals(self, configuration): if configuration.files.normal is not None: self._normal_collection.empty() total = self._normal_collection.load_from_filename( configuration.files.normal) YLogger.info(self, "Loaded a total of %d normalisations", total) else: YLogger.warning(self, "No configuration setting for normal") def _load_genders(self, configuration): if configuration.files.gender is not None: self._gender_collection.empty() total = self._gender_collection.load_from_filename( configuration.files.gender) YLogger.info(self, "Loaded a total of %d genderisations", total) else: YLogger.warning(self, "No configuration setting for gender") def _load_persons(self, configuration): if configuration.files.person is not None: self._person_collection.empty() total = self._person_collection.load_from_filename( configuration.files.person) YLogger.info(self, "Loaded a total of %d persons", total) else: YLogger.warning(self, "No configuration setting for person") def _load_person2s(self, configuration): if configuration.files.person2 is not None: self._person2_collection.empty() total = self._person2_collection.load_from_filename( configuration.files.person2) YLogger.info(self, "Loaded a total of %d person2s", total) else: YLogger.warning(self, "No configuration setting for person2") def _load_properties(self, configuration): if configuration.files.properties is not None: self._properties_collection.empty() total = self._properties_collection.load_from_filename( configuration.files.properties) YLogger.info(self, "Loaded a total of %d properties", total) else: YLogger.warning(self, "No configuration setting for properties") def _save_variables(self, client_context): # NOTE: Added by Jarid 7/28 self._variables_collection.save_to_database(client_context) def _load_variables(self, client_context): # TODO ROHOLA: Refactor this funciton # TODO: Add in load from db here, need to find a way to retrieve proper clientid # if configuration.files.variables is not None: # print("Loading variables") self._variables_collection.empty() self._variables_collection.load_from_database(client_context) # YLogger.info(self, "Loaded a total of %d variables", total) # else: # YLogger.warning(self, "No configuration setting for variables") def _load_maps(self, configuration): self._maps_collection.empty() total = self._maps_collection.load(configuration.files.map_files) YLogger.info(self, "Loaded a total of %d maps files", total) def reload_map(self, mapname): if self._maps_collection.contains(mapname): filename = self._maps_collection.filename(mapname) self._maps_collection.reload_file(filename) def _load_sets(self, configuration): self._sets_collection.empty() total = self._sets_collection.load(configuration.files.set_files) YLogger.info(self, "Loaded a total of %d sets files", total) def reload_set(self, setname): if self._sets_collection.contains(setname): filename = self._sets_collection.filename(setname) self._sets_collection.reload_file(filename) def _load_rdfs(self, configuration): if configuration.files.rdf_files is not None and configuration.files.rdf_files.files: self._rdf_collection.empty() total = self._rdf_collection.load(configuration.files.rdf_files) YLogger.info(self, "Loaded a total of %d rdf files", total) elif configuration.files.triples is not None: self._rdf_collection.empty() total = self._rdf_collection.load_from_filename( configuration.files.triples) YLogger.info(self, "Loaded a total of %d triples", total) else: YLogger.warning(self, "No configuration setting for triples") def reload_rdf(self, rdfname): if self._rdf_collection.contains(rdfname): self._rdf_collection.reload_file(rdfname) def _load_preprocessors(self, configuration): if configuration.files.preprocessors is not None: self._preprocessors.empty() total = self._preprocessors.load(configuration.files.preprocessors) YLogger.info(self, "Loaded a total of %d pre processors", total) else: YLogger.warning(self, "No configuration setting for pre processors") def _load_postprocessors(self, configuration): if configuration.files.postprocessors is not None: self._postprocessors.empty() total = self._postprocessors.load( configuration.files.postprocessors) YLogger.info(self, "Loaded a total of %d post processors", total) else: YLogger.warning(self, "No configuration setting for post processors") def load_collections(self, configuration): self._load_denormals(configuration) self._load_normals(configuration) self._load_genders(configuration) self._load_persons(configuration) self._load_person2s(configuration) self._load_properties(configuration) # self._load_variables(configuration) This function call might need to be moved to the client folder. self._load_rdfs(configuration) self._load_sets(configuration) self._load_maps(configuration) self._load_preprocessors(configuration) self._load_postprocessors(configuration) def load_services(self, configuration): YLogger.debug(self, "Loading Services.") ServiceFactory.preload_services(configuration.services) def load_security_services(self, configuration): if configuration.security is not None: if configuration.security.authentication is not None: if configuration.security.authentication.classname is not None: try: classobject = ClassLoader.instantiate_class( configuration.security.authentication.classname) self._authentication = classobject( configuration.security.authentication) except Exception as excep: YLogger.exception(self, "Failed to load security services", excep) else: YLogger.debug(self, "No authentication configuration defined") if configuration.security.authorisation is not None: if configuration.security.authorisation.classname is not None: try: classobject = ClassLoader.instantiate_class( configuration.security.authorisation.classname) self._authorisation = classobject( configuration.security.authorisation) except Exception as excep: YLogger.exception( self, "Failed to instatiate authorisation class", excep) else: YLogger.debug(self, "No authorisation configuration defined") else: YLogger.debug( self, "No security configuration defined, running open...") def load_dynamics(self, configuration): if configuration.dynamics is not None: self._dynamics_collection.load_from_configuration( configuration.dynamics) else: YLogger.debug(self, "No dynamics configuration defined...") def pre_process_question(self, client_context, question): return self.preprocessors.process(client_context, question) def load_oob_processors(self, configuration): if configuration.oob is not None: if configuration.oob.default() is not None: try: YLogger.info(self, "Loading default oob") classobject = ClassLoader.instantiate_class( configuration.oob.default().classname) self._default_oob = classobject() except Exception as excep: YLogger.exception(self, "Failed to load OOB Processor", excep) for oob_name in configuration.oob.oobs(): try: YLogger.info(self, "Loading oob: %s", oob_name) classobject = ClassLoader.instantiate_class( configuration.oob.oob(oob_name).classname) self._oob[oob_name] = classobject() except Exception as excep: YLogger.exception(self, "Failed to load OOB", excep) def load_regex_templates(self, configuration): if configuration.files.regex_templates is not None: collection = PropertiesCollection() total = collection.load_from_filename( configuration.files.regex_templates) YLogger.info(self, "Loaded a total of %d regex templates", total) self._regex_templates.clear() for pair in collection.pairs: name = pair[0] pattern = pair[1] try: self._regex_templates[name] = re.compile( pattern, re.IGNORECASE) except Exception: YLogger.error(self, "Invalid regex template [%s]", pattern) def regex_template(self, name): if name in self._regex_templates: return self._regex_templates[name] return None def strip_oob(self, response): match = re.compile(r"(.*)(<\s*oob\s*>.*<\/\s*oob\s*>)(.*)") groupings = match.match(response) if groupings is not None: front = groupings.group(1).strip() back = groupings.group(3).strip() response = "" if front != "": response = front + " " response += back oob = groupings.group(2) return response, oob return response, None def process_oob(self, client_context, oob_command): oob_content = ET.fromstring(oob_command) if oob_content.tag == 'oob': for child in oob_content.findall('./'): if child.tag in self._oob: oob_class = self._oob[child.tag] return oob_class.process_out_of_bounds( client_context, child) return self._default_oob.process_out_of_bounds( client_context, child) return "" def post_process_response(self, client_context, response: str): return self.postprocessors.process(client_context, response) def failed_authentication(self, client_context): YLogger.error(client_context, "[%s] failed authentication!") # If we have an SRAI defined, then use that if self.authentication.configuration.denied_srai is not None: match_context = self._aiml_parser.match_sentence( client_context, Sentence(self._bot.brain.nlp.tokenizer, self.authentication.configuration.denied_srai), topic_pattern="*", that_pattern="*") # If the SRAI matched then return the result if match_context is not None: return self.resolve_matched_template(client_context, match_context) # Otherswise return the static text, which is either # User defined via config.yaml # Or use the default value BrainSecurityConfiguration.DEFAULT_ACCESS_DENIED return self.authentication.configuration.denied_text def authenticate_user(self, client_context): if self.authentication is not None: if self.authentication.authenticate(client_context) is False: return self.failed_authentication(client_context) return None def resolve_matched_template_with_options(self, client_context, match_context): template_node = match_context.template_node() YLogger.debug(client_context, "AIML Parser evaluating template [%s]", template_node.to_string()) response = template_node.template.resolve(client_context) options = {} if "<oob>" in response: response, oob = self.strip_oob(response) if oob is not None: options = self.process_oob(client_context, oob) return response, options def resolve_matched_template(self, client_context, match_context): template_node = match_context.template_node() YLogger.debug(client_context, "AIML Parser evaluating template [%s]", template_node.to_string()) response = template_node.template.resolve(client_context) # if "<oob>" in response: # response, oob = self.strip_oob(response) # if oob is not None: # oob_response = self.process_oob(client_context, oob) # response = response + " " + oob_response return response def ask_question(self, client_context, sentence, srai=False): client_context.brain = self authenticated = self.authenticate_user(client_context) if authenticated is not None: return authenticated conversation = client_context.bot.get_conversation(client_context) topic_pattern = conversation.get_topic_pattern(client_context) that_pattern = conversation.get_that_pattern(client_context, srai) match_context = self._aiml_parser.match_sentence( client_context, sentence, topic_pattern=topic_pattern, that_pattern=that_pattern) if match_context is not None: return self.resolve_matched_template(client_context, match_context) return None def ask_question_with_options(self, client_context, sentence, srai=False): client_context.brain = self authenticated = self.authenticate_user(client_context) if authenticated is not None: return authenticated conversation = client_context.bot.get_conversation(client_context) topic_pattern = conversation.get_topic_pattern(client_context) that_pattern = conversation.get_that_pattern(client_context, srai) match_context = self._aiml_parser.match_sentence( client_context, sentence, topic_pattern=topic_pattern, that_pattern=that_pattern) if match_context is not None: return self.resolve_matched_template_with_options( client_context, match_context) return None, {"robot": None}
def test_unify_on_single_var_with_not(self): collection = RDFCollection() self.assertIsNotNone(collection) collection.add_entity("MONKEY", "LEGS", "2") collection.add_entity("MONKEY", "HASFUR", "true") collection.add_entity("ZEBRA", "LEGS", "4") collection.add_entity("BIRD", "LEGS", "2") collection.add_entity("ELEPHANT", "TRUNK", "true") set1 = collection.match_to_vars("?x", "LEGS", "2") set2 = collection.not_match_to_vars("?x", "HASFUR", "true") unified = collection.unify(["?x"], [set1, set2]) self.assertIsNotNone(unified) self.assertEquals(1, len(unified)) self.assertTrue([['?x', 'BIRD']] in unified)