def initiate_sentiment_analyser(sentiment_config): if sentiment_config.classname is not None: analyser = None scores = None try: YLogger.debug(None, "Loading sentiment analyser from class [%s]", sentiment_config.classname) sentiment_class = ClassLoader.instantiate_class(sentiment_config.classname) analyser = sentiment_class() analyser.initialise() except Exception as excep: YLogger.exception(None, "Failed to initiate sentiment analyser", excep) try: YLogger.debug(None, "Loading sentiment scores from class [%s]", sentiment_config.classname) scores_class = ClassLoader.instantiate_class(sentiment_config.scores) scores = scores_class() except Exception as excep: YLogger.exception(None, "Failed to initiate sentiment analyser", excep) return analyser, scores else: YLogger.debug(None, "No configuration setting for sentiment analyser!") return None, None
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, 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, excep) else: YLogger.debug(self, "No authorisation configuration defined") else: YLogger.debug( self, "No security configuration defined, running open...")
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_security_services(self, brain_configuration): if brain_configuration.security is not None: if brain_configuration.security.authentication is not None: if brain_configuration.security.authentication.classname is not None: try: classobject = ClassLoader.instantiate_class( brain_configuration.security.authentication. classname) self._authentication = classobject( brain_configuration.security.authentication) except Exception as excep: logging.exception(excep) else: if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("No authentication configuration defined") if brain_configuration.security.authorisation is not None: if brain_configuration.security.authorisation.classname is not None: try: classobject = ClassLoader.instantiate_class( brain_configuration.security.authorisation. classname) self._authorisation = classobject( brain_configuration.security.authorisation) except Exception as excep: logging.exception(excep) else: if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("No authorisation configuration defined") else: if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug( "No security configuration defined, running open...")
def load_security_services(self, client): if self._configuration is not None: if self._configuration.authentication is not None: if self._configuration.authentication.classname is not None: try: classobject = ClassLoader.instantiate_class( self._configuration.authentication.classname) self._authentication = classobject( self._configuration.authentication) self._authentication.initialise(client) except Exception as excep: YLogger.exception(self, "Failed to load security services", excep) else: YLogger.debug(self, "No authentication configuration defined") if self._configuration.authorisation is not None: if self._configuration.authorisation.classname is not None: try: classobject = ClassLoader.instantiate_class( self._configuration.authorisation.classname) self._authorisation = classobject( self._configuration.authorisation) self._authorisation.initialise(client) 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 preload_services(cls, service_configs): loader = ClassLoader() for service_config in service_configs: name = service_config.name.upper() logging.debug("Preloading service [%s] -> [%s]", name, service_config.path) meta_class = loader.instantiate_class(service_config.path) new_class = meta_class(service_config) ServiceFactory.services[name] = new_class
def preload_services(cls, services_config): loader = ClassLoader() for service_name in services_config.services(): name = service_name.upper() service_config = services_config.service(service_name) YLogger.debug(None, "Preloading service [%s] -> [%s]", name, service_config.classname) meta_class = loader.instantiate_class(service_config.classname) new_class = meta_class(service_config) ServiceFactory.services[name] = new_class
def test_instantiate_module_class(self): loader = ClassLoader() self.assertIsNotNone(loader) meta_class = loader.instantiate_class("test.testclass.TestClass") self.assertIsNotNone(meta_class) new_class = meta_class() self.assertIsNotNone(new_class) self.assertTrue(new_class.test_method())
def preload_services(cls, services_config): loader = ClassLoader() for service_name in services_config.services(): name = service_name.upper() service_config = services_config.service(service_name) if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("Preloading service [%s] -> [%s]", name, service_config.classname) meta_class = loader.instantiate_class(service_config.classname) new_class = meta_class(service_config) ServiceFactory.services[name] = new_class
def test_instantiate_module_class(self): loader = ClassLoader() self.assertIsNotNone(loader) meta_class = loader.instantiate_class("test.utils.classes.testclass.TestClass") self.assertIsNotNone(meta_class) new_class = meta_class() self.assertIsNotNone(new_class) self.assertTrue(new_class.test_method())
def preload_services(cls, service_configs): loader = ClassLoader() for service_config in service_configs: name = service_config.name.upper() logging.debug("Preloading service [%s] -> [%s]", name, service_config.path) meta_class = loader.instantiate_class(service_config.path) new_class = meta_class(service_config) ServiceFactory.services[name] = new_class
def preload_services(cls, services_config): loader = ClassLoader() for service_name in services_config.services(): name = service_name.upper() service_config = services_config.service(service_name) YLogger.debug(None, "Preloading service [%s] -> [%s]", name, service_config.classname) meta_class = loader.instantiate_class(service_config.classname) new_class = meta_class(service_config) ServiceFactory.services[name] = new_class
def setUp(self): bot_config = BotConfiguration() bot = Bot(bot_config, TestClient()) bot.brain.configuration.debugfiles._save_errors = True bot.brain.configuration.debugfiles._save_duplicates = True bot.brain.template_factory.add_node( "base", ClassLoader.instantiate_class( "programy.parser.template.nodes.base.TemplateNode")) bot.brain.template_factory.add_node( "word", ClassLoader.instantiate_class( "programy.parser.template.nodes.word.TemplateWordNode")) bot.brain.pattern_factory.add_node( "oneormore", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.oneormore.PatternOneOrMoreWildCardNode" )) bot.brain.pattern_factory.add_node( "topic", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.topic.PatternTopicNode")) bot.brain.pattern_factory.add_node( "that", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.that.PatternThatNode")) bot.brain.pattern_factory.add_node( "template", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.template.PatternTemplateNode")) bot.brain.pattern_factory.add_node( "bot", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.bot.PatternBotNode")) bot.brain.pattern_factory.add_node( "set", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.set.PatternSetNode")) bot.brain.pattern_factory.add_node( "nlu", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.nlu.PatternNluNode")) bot.brain.pattern_factory.add_node( "word", ClassLoader.instantiate_class( "programy.parser.pattern.nodes.word.PatternWordNode")) self.parser = bot.brain.aiml_parser self.parser.create_debug_storage() self.assertIsNotNone(self.parser)
def load_tokenizer(configuration): if configuration is not None and configuration.tokenizer.classname is not None: YLogger.debug(None, "Loading tokenizer from class [%s]", configuration.tokenizer.classname) tokenizer_class = ClassLoader.instantiate_class(configuration.tokenizer.classname) return tokenizer_class(configuration.tokenizer.split_chars, configuration.tokenizer.punctuation_chars, configuration.tokenizer.before_concatenation_rule, configuration.tokenizer.after_concatenation_rule) else: tokenizer_class = ClassLoader.instantiate_class('programy.dialog.tokenizer.tokenizer_jp.TokenizerJP') return tokenizer_class(configuration.tokenizer.split_chars, configuration.tokenizer.punctuation_chars, configuration.tokenizer.before_concatenation_rule, configuration.tokenizer.after_concatenation_rule)
def load(self, collector, name=None): nodes = self.get_all_nodes() for node in nodes: try: collector.add_node(node.name, ClassLoader.instantiate_class(node.node_class)) except Exception as e: YLogger.exception(self, "Failed pre-instantiating %s Node [%s]", e, collector.type, node.node_class)
def _load_file_contents(self, processor_collection, filename): YLogger.debug(self, "Loading processors from file [%s]", filename) count = 0 line_no = 0 try: with open(filename, "r", encoding="utf-8") as file: for line in file: line_no += 1 line = line.strip() if line: if line[0] != '#': class_name = line.split() try: new_class = ClassLoader.instantiate_class( class_name[0]) processor_collection.add_processor(new_class()) count += 1 except Exception: error_info = "processor [%s] not found" % line processor_collection.set_error_info( filename, line_no, error_info) except FileNotFoundError: YLogger.error(self, "File not found [%s]", filename) return count
def load_tokenizer(self): if self.configuration is not None and self.configuration.tokenizer.classname is not None: YLogger.info(self, "Loading tokenizer from class [%s]", self.configuration.tokenizer.classname) tokenizer_class = ClassLoader.instantiate_class(self.configuration.tokenizer.classname) return tokenizer_class(self.configuration.tokenizer.split_chars) else: return Tokenizer(self.configuration.tokenizer.split_chars)
def load(self, collector, name=None): processors = self.get_all_processors() for processor in processors: try: collector.add_processor(ClassLoader.instantiate_class(processor.classname)()) except Exception as e: YLogger.exception(self, "Failed pre-instantiating Processor [%s]", e, processor.classname)
def get_root_node(self): try: root_class = self.new_node_class('root') return root_class() except: return ClassLoader.instantiate_class( "programy.parser.pattern.nodes.root.PatternRootNode")()
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_brain_selector(self, configuration): if configuration.brain_selector is None: self._brain_selector = DefaultBrainSelector(configuration) else: try: self._brain_selector = ClassLoader.instantiate_class(configuration.brain_selector)(configuration) except Exception as e: self._brain_selector = DefaultBrainSelector(configuration)
def load_brain_selector(self, configuration): if configuration.brain_selector is None: self._brain_selector = DefaultBrainSelector(configuration, self._brains) else: try: self._brain_selector = ClassLoader.instantiate_class(configuration.brain_selector)(configuration, self._brains) except Exception as e: self._brain_selector = DefaultBrainSelector(configuration, self._brains)
def load_tokenizer(self): if self._configuration is not None and self._configuration.tokenizer.classname is not None: if logging.getLogger().isEnabledFor(logging.INFO): logging.info("Loading tokenizer from class [%s]", self._configuration.tokenizer.classname) tokenizer_class = ClassLoader.instantiate_class(self._configuration.tokenizer.classname) return tokenizer_class(self._configuration.tokenizer.split_chars) else: return Tokenizer(self._configuration.tokenizer.split_chars)
def _load_account_linking_class(self, client): if self._configuration.account_linker is not None: if self._configuration.account_linker.classname is not None: classobject = ClassLoader.instantiate_class( self._configuration.account_linker.classname) self._account_linker = classobject( self._configuration.account_linker) self.account_linker.initialise(client)
def load_bot_selector(self, configuration): if configuration.bot_selector is None: self._bot_selector = DefaultBotSelector(configuration) else: try: self._bot_selector = ClassLoader.instantiate_class(configuration.bot_selector)(configuration) except Exception: self._bot_selector = DefaultBotSelector(configuration)
def _load_authorisation_class(self, client): if self._configuration.authorisation is not None: if self._configuration.authorisation.classname is not None: classobject = ClassLoader.instantiate_class( self._configuration.authorisation.classname) self._authorisation = classobject( self._configuration.authorisation) self._authorisation.initialise(client)
def add_trigger(self, event: str, classname: str): try: trigger = ClassLoader.instantiate_class(classname)() if event not in self._triggers: self._triggers[event] = [] self._triggers[event].append(trigger) except Exception as e: YLogger.exception(self, "Failed to add trigger [%s] -> [%s]", e, event, classname)
def load(self, node_factory): YLogger.debug(self, "Loading %s nodes from Mongo", self.collection_name()) nodes = self.get_all_nodes() for node in nodes: try: node_factory.add_node(node['name'], ClassLoader.instantiate_class(node['node_class'])) except Exception as e: YLogger.exception(self, "Failed pre-instantiating %s Node [%s]", e, node_factory.type, node['node_class'])
def resolve_to_string(self, client_context): data = self.resolve_children_to_string(client_context) new_class = ClassLoader.instantiate_class(self._path) instance = new_class() resolved = instance.execute(client_context, data) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def load(self, handler, name=None): oobs = self.get_all_oobs() for oob in oobs: try: handler.add_oob(oob.name, ClassLoader.instantiate_class(oob.oob_class)()) except Exception as e: YLogger.exception(self, "Failed pre-instantiating OOB [%s]", e, oob.oob_class)
def load(self, collector, name=None): YLogger.info(self, "Loading %s triggers from Mongo", self.collection_name()) triggers = self.get_all_triggers() for trigger in triggers: try: collector.add_trigger(trigger['name'], ClassLoader.instantiate_class(trigger['trigger_class'])()) except Exception as excep: YLogger.exception(self, "Failed pre-instantiating Trigger [%s]", excep, trigger['trigger_class'])
def load_renderer(self): try: if self.get_client_configuration().renderer is not None: clazz = ClassLoader.instantiate_class(self.get_client_configuration().renderer.renderer) return clazz(self) except Exception as e: YLogger.exception(None, "Failed to load config specified renderer", e) return self.get_default_renderer()
def resolve_to_string(self, client_context): data = self.resolve_children_to_string(client_context) new_class = ClassLoader.instantiate_class(self._path) instance = new_class() resolved = instance.execute(client_context, data) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def load(self, filename, *args, **kw): logging.debug("Loading processors from file [%s]", filename) count = 0 with open(filename, "r+") as file: for line in file: new_class = ClassLoader.instantiate_class(line) if new_class is not None: self.processors.append(new_class(*args, **kw)) count += 1 return count
def load(self, filename, *args, **kw): logging.debug("Loading processors from file [%s]", filename) count = 0 with open(filename, "r+") as file: for line in file: new_class = ClassLoader.instantiate_class(line) if new_class is not None: self.processors.append(new_class(*args, **kw)) count += 1 return count
def load_oob_processors(self, brain_configuration): if brain_configuration.oob is not None: if brain_configuration.oob.default() is not None: try: if logging.getLogger().isEnabledFor(logging.INFO): logging.info("Loading default oob") classobject = ClassLoader.instantiate_class(brain_configuration.oob.default().classname) self._default_oob = classobject() except Exception as excep: logging.exception(excep) for oob_name in brain_configuration.oob.oobs(): try: if logging.getLogger().isEnabledFor(logging.INFO): logging.info("Loading oob: %s", oob_name) classobject = ClassLoader.instantiate_class(brain_configuration.oob.oob(oob_name).classname) self._oob[oob_name] = classobject() except Exception as excep: logging.exception(excep)
def load(self, collector, name=None): YLogger.info(self, "Loading %s nodes from Mongo", self.collection_name()) nodes = self.get_all_nodes() for node in nodes: try: collector.add_processor(ClassLoader.instantiate_class(node['classname'])()) except Exception as excep: YLogger.exception(self, "Failed pre-instantiating Processor [%s]", excep, node['classname'])
def resolve_to_string(self, bot, clientid): data = self.resolve_children_to_string(bot, clientid) new_class = ClassLoader.instantiate_class(self._path) instance = new_class() resolved = instance.execute(bot, clientid, data) if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def initiate_spellchecker(self): # TODO Move this to Spelling bass class if self.configuration is not None: if self.configuration.spelling.classname is not None: try: YLogger.info(self, "Loading spelling checker from class [%s]", self.configuration.spelling.classname) spell_class = ClassLoader.instantiate_class(self.configuration.spelling.classname) self._spell_checker = spell_class(self.configuration.spelling) except Exception as excep: YLogger.exception(self, "Failed to initiate spellcheker", excep) else: YLogger.warning(self, "No configuration setting for spelling checker!")
def process_config_line(self, line): if self.valid_config_line(line): splits = line.split("=") node_name = splits[0].strip() if node_name in self._nodes_config: YLogger.error(self, "Node already exists in config [%s]", line) return class_name = splits[1].strip() YLogger.debug(self, "Pre-instantiating %s Node [%s]", self._type, class_name) try: self._nodes_config[node_name] = ClassLoader.instantiate_class(class_name) except Exception as e: YLogger.exception(self, "Failed pre-instantiating %s Node [%s]"%(self._type, class_name), e)
def resolve(self, bot, clientid): try: data = self.resolve_children_to_string(bot, clientid) new_class = ClassLoader.instantiate_class(self._path) if new_class is not None: instance = new_class() resolved = instance.execute(data) logging.debug("[%s] resolved to [%s]", self.to_string(), resolved) return resolved except Exception as excep: logging.exception(excep) logging.error("Extension [%s] failed to execute", self._path) return ""
def __init__(self): ClassLoader.__init__(self) self.processors = []
def add_dynamic_set(self, name, classname, config_file): self._dynamic_sets[name.upper()] = (ClassLoader.instantiate_class(classname))(config_file)