def inject_context(self, entity, metadata=None): """ Args: entity(object): Format example... {'data': 'Entity tag as <str>', 'key': 'entity proper name as <str>', 'confidence': <float>' } metadata(object): dict, arbitrary metadata about entity injected """ metadata = metadata or {} try: if len(self.frame_stack) > 0: top_frame = self.frame_stack[0] else: top_frame = None if top_frame and top_frame[0].metadata_matches(metadata): top_frame[0].merge_context(entity, metadata) else: frame = ContextManagerFrame(entities=[entity], metadata=metadata.copy()) self.frame_stack.insert(0, (frame, time.time())) except (IndexError, KeyError): pass except Exception as e: LOG.exception(e)
def register_keyword_intent_from_file(self, intent_name, file_name): LOG.info("Registering keyword intent file: " + file_name) with open(file_name) as f: samples = [l.strip() for l in f.readlines() if l.strip() and not l.startswith( "#") and not l.startswith("//")] self.register_keyword_intent(intent_name, samples)
def register_palavreado_intent(self, intent_name, samples=None, optional_samples=None): LOG.info("Registering palavreado intent: " + intent_name) optional_samples = optional_samples or [] if self.engines["palavreado"]: self.engines["palavreado"].register_intent(intent_name, samples, optional_samples)
def register_adapt_intent(self, intent_name, samples=None, optional_samples=None): LOG.info("Registering adapt intent: " + intent_name) optional_samples = optional_samples or [] if self.engines["adapt"]: self.engines["adapt"].register_intent(intent_name, samples, optional_samples)
def detach_skill(self, skill_id): LOG.debug("detaching adapt skill: " + skill_id) new_parsers = [ p.name for p in self.engine.intent_parsers if p.name.startswith(skill_id)] for intent_name in new_parsers: self.detach_intent(intent_name)
def register_nebulento_entity_from_file(self, entity_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering nebulento entity file: " + file_name) try: self.engines["nebulento"].register_entity_from_file( entity_name, file_name) except Exception as e: LOG.error("Could not register file: " + file_name)
def register_palavreado_regex_from_file(self, entity_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering palavreado regex file: " + file_name) with open(file_name) as f: samples = [l.strip() for l in f.readlines() if l.strip() and not l.startswith( "#") and not l.startswith("//")] self.register_palavreado_regex_entity(entity_name, samples)
def register_palavreado_intent_from_file(self, intent_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering palavreado intent file: " + file_name) if self.engines["palavreado"]: with open(file_name) as f: samples = [l.strip() for l in f.readlines() if l.strip() and not l.startswith( "#") and not l.startswith("//")] self.engines["palavreado"].register_intent(intent_name, samples)
def register_keyword_intent(self, intent_name, samples=None, optional_samples=None): LOG.info("Registering keyword intent: " + intent_name) for parser, engine in self.engines.items(): if not engine or not engine.keyword_based: continue self.engines[parser].register_intent(intent_name, samples, optional_samples)
def calc_intent(self, utterance): utterance = utterance.strip().lower() # best intent intents = [] for parser, engine in self.engines.items(): if engine: intent = engine.calc_intent(utterance) LOG.debug(f"{parser} match: {intent}") intents.append(intent) intents = self.normalize_intent_scores(intents) intents = [i for i in intents if i["conf"] >= 0.45] if not intents: return None return sorted(intents, key=lambda k: k["conf"], reverse=True)[0]
def register_intent_from_file(self, intent_name, file_name, single_thread=True, timeout=120, reload_cache=True, force_training=True): try: with self.lock: self.container.load_intent(intent_name, file_name, reload_cache=reload_cache) self.registered_intents.append(intent_name) success = self._train(single_thread=single_thread, timeout=timeout, force_training=force_training) if success: LOG.debug(file_name + " trained successfully") else: LOG.error(file_name + " FAILED TO TRAIN") except Exception as e: LOG.exception(e)
def register_adapt_entity(self, entity_name, samples=None): LOG.info("Registering adapt entity: " + entity_name) if self.engines["adapt"]: self.engines["adapt"].register_entity(entity_name, samples)
def detach_intent(self, intent_name): if intent_name in self.registered_intents: LOG.debug("Detaching padatious intent: " + intent_name) with self.lock: self.container.remove_intent(intent_name) self.registered_intents.remove(intent_name)
def detach_skill(self, skill_id): LOG.debug("Detaching padatious skill: " + str(skill_id)) remove_list = [i for i in self.registered_intents if skill_id in i] for i in remove_list: self.detach_intent(i)
def register_nebulento_entity(self, entity_name, samples=None): LOG.info("Registering nebulento entity: " + entity_name) self.engines["nebulento"].register_entity(entity_name, samples)
def detach_intent(self, intent_name): if intent_name in self.registered_intents: LOG.debug("Detaching padacioso intent: " + intent_name) self.container.remove_intent(intent_name) self.registered_intents.remove(intent_name)
def register_nebulento_intent(self, intent_name, samples=None): LOG.info("Registering nebulento intent: " + intent_name) self.engines["nebulento"].register_intent(intent_name, samples)
def register_nebulento_intent_from_file(self, intent_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering nebulento intent file: " + file_name) self.engines["nebulento"].register_intent_from_file( intent_name, file_name)
def register_padacioso_intent_from_file(self, intent_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering padacioso intent file: " + file_name) self.engines["padacioso"].register_intent_from_file( intent_name, file_name)
def register_padacioso_entity(self, entity_name, samples=None): LOG.info("Registering padacioso entity: " + entity_name) self.engines["padacioso"].register_entity(entity_name, samples)
def register_palavreado_regex_entity(self, entity_name, regex_str): LOG.info("Registering palavreado regex: " + regex_str) self.engines["palavreado"].register_regex_entity( entity_name, regex_str)
def register_padacioso_intent(self, intent_name, samples=None): LOG.info("Registering padacioso intent: " + intent_name) self.engines["padacioso"].register_intent(intent_name, samples)
def register_palavreado_entity(self, entity_name, samples=None): LOG.info("Registering palavreado entity: " + entity_name) if self.engines["palavreado"]: self.engines["palavreado"].register_entity(entity_name, samples)
def register_adapt_regex_entity(self, entity_name, regex_str): LOG.info("Registering adapt regex: " + regex_str) if self.engines["adapt"]: self.engines["adapt"].register_regex_entity(entity_name, regex_str)
def get_context(self, max_frames=5, missing_entities=None): """ Constructs a list of entities from the context. Args: max_frames(int): maximum number of frames to look back missing_entities(list of str): a list or set of tag names, as strings Returns: list: a list of entities """ try: missing_entities = missing_entities or [] relevant_frames = [ frame[0] for frame in self.frame_stack if time.time() - frame[1] < self.timeout ] if not max_frames or max_frames > len(relevant_frames): max_frames = len(relevant_frames) missing_entities = list(missing_entities) context = [] last = '' depth = 0 for i in range(max_frames): frame_entities = [ entity.copy() for entity in relevant_frames[i].entities ] for entity in frame_entities: entity['confidence'] = entity.get('confidence', 1.0) \ / (2.0 + depth) context += frame_entities # Update depth if entity['origin'] != last or entity['origin'] == '': depth += 1 last = entity['origin'] result = [] if len(missing_entities) > 0: for entity in context: if entity.get('data') in missing_entities: result.append(entity) # NOTE: this implies that we will only ever get one # of an entity kind from context, unless specified # multiple times in missing_entities. Cannot get # an arbitrary number of an entity kind. missing_entities.remove(entity.get('data')) else: result = context # Only use the latest instance of each keyword stripped = [] processed = [] for f in result: keyword = f['data'][0][1] if keyword not in processed: stripped.append(f) processed.append(keyword) result = stripped except Exception as e: LOG.exception(e) return [] #LOG.debug("Adapt Context: {}".format(result)) return result
def register_adapt_intent_from_file(self, intent_name, file_name): file_name = resolve_resource_file(file_name) LOG.info("Registering adapt intent file: " + file_name) self.register_adapt_entity_from_file(intent_name, file_name) self.register_adapt_intent(intent_name)
def detach_intent(self, intent_name): LOG.debug("detaching adapt intent: " + intent_name) new_parsers = [ p for p in self.engine.intent_parsers if p.name != intent_name] self.engine.intent_parsers = new_parsers