def parse(self, text, intents=None):
"""Performs intent parsing on the provided *text* by calling its intent
parsers successively
Args:
text (str): Input
intents (str or list of str): If provided, reduces the scope of
intent parsing to the provided list of intents
Returns:
dict: The most likely intent along with the extracted slots. See
:func:`.parsing_result` for the output format.
Raises:
NotTrained: When the nlu engine is not fitted
TypeError: When input type is not unicode
"""
logging.info("NLU engine parsing: '%s'...", text)
if not isinstance(text, str):
raise TypeError("Expected unicode but received: %s" % type(text))
if isinstance(intents, str):
intents = [intents]
for parser in self.intent_parsers:
res = parser.parse(text, intents)
if is_empty(res):
continue
resolved_slots = self.resolve_slots(text, res[RES_SLOTS])
return parsing_result(text,
intent=res[RES_INTENT],
slots=resolved_slots)
return empty_result(text)
def parse(self, text, intents=None, top_n=None):
"""Performs intent parsing on the provided *text* by calling its intent
parsers successively
Args:
text (str): Input
intents (str or list of str, optional): If provided, reduces the
scope of intent parsing to the provided list of intents
top_n (int, optional): when provided, this method will return a
list of at most top_n most likely intents, instead of a single
parsing result.
Note that the returned list can contain less than ``top_n``
elements, for instance when the parameter ``intents`` is not
None, or when ``top_n`` is greater than the total number of
intents.
Returns:
dict or list: the most likely intent(s) along with the extracted
slots. See :func:`.parsing_result` and :func:`.extraction_result`
for the output format.
Raises:
NotTrained: When the nlu engine is not fitted
InvalidInputError: When input type is not unicode
"""
if not isinstance(text, str):
raise InvalidInputError("Expected unicode but received: %s" %
type(text))
if isinstance(intents, str):
intents = {intents}
elif isinstance(intents, list):
intents = set(intents)
if top_n is None:
none_proba = 0.0
for parser in self.intent_parsers:
res = parser.parse(text, intents)
if is_empty(res):
none_proba = res[RES_INTENT][RES_PROBA]
continue
resolved_slots = self._resolve_slots(text, res[RES_SLOTS])
return parsing_result(text,
intent=res[RES_INTENT],
slots=resolved_slots)
return empty_result(text, none_proba)
intents_results = self.get_intents(text)
if intents is not None:
intents_results = [
res for res in intents_results
if res[RES_INTENT_NAME] in intents
]
intents_results = intents_results[:top_n]
results = []
for intent_res in intents_results:
slots = self.get_slots(text, intent_res[RES_INTENT_NAME])
results.append(extraction_result(intent_res, slots))
return results
def parse(self, text, intents=None):
"""Performs intent parsing on the provided *text* by calling its intent
parsers successively
Args:
text (str): Input
intents (str or list of str): If provided, reduces the scope of
intent parsing to the provided list of intents
Returns:
dict: The most likely intent along with the extracted slots. See
:func:`.parsing_result` for the output format.
Raises:
NotTrained: When the nlu engine is not fitted
TypeError: When input type is not unicode
"""
logging.info("NLU engine parsing: '%s'...", text)
if not isinstance(text, str):
raise TypeError("Expected unicode but received: %s" % type(text))
if not self.fitted:
raise NotTrained("SnipsNLUEngine must be fitted")
if isinstance(intents, str):
intents = [intents]
language = self._dataset_metadata["language_code"]
entities = self._dataset_metadata["entities"]
for parser in self.intent_parsers:
res = parser.parse(text, intents)
if is_empty(res):
continue
slots = res[RES_SLOTS]
scope = [
s[RES_ENTITY] for s in slots
if is_builtin_entity(s[RES_ENTITY])
]
resolved_slots = resolve_slots(text, slots, entities, language,
scope)
return parsing_result(text,
intent=res[RES_INTENT],
slots=resolved_slots)
return empty_result(text)
def parse(self, text, intents=None):
"""Performs intent parsing on the provided *text* by calling its intent
parsers successively
Args:
text (str): Input
intents (str or list of str): If provided, reduces the scope of
intent parsing to the provided list of intents
Returns:
dict: The most likely intent along with the extracted slots. See
:func:`.parsing_result` for the output format.
Raises:
NotTrained: When the nlu engine is not fitted
TypeError: When input type is not unicode
"""
if not isinstance(text, str):
raise TypeError("Expected unicode but received: %s" % type(text))
if not self.fitted:
raise NotTrained("SnipsNLUEngine must be fitted")
if isinstance(intents, str):
intents = [intents]
language = self._dataset_metadata["language_code"]
entities = self._dataset_metadata["entities"]
for parser in self.intent_parsers:
res = parser.parse(text, intents)
if is_empty(res):
continue
slots = res[RES_SLOTS]
scope = [s[RES_ENTITY] for s in slots
if is_builtin_entity(s[RES_ENTITY])]
resolved_slots = resolve_slots(text, slots, entities, language,
scope)
return parsing_result(text, intent=res[RES_INTENT],
slots=resolved_slots)
return empty_result(text)
