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
