def __init__(self, *args, **kwargs):
super(LuisRecognizerTest, self).__init__(*args, **kwargs)
self._mocked_results: RecognizerResult = RecognizerResult(
intents={"Test": IntentScore(score=0.2), "Greeting": IntentScore(score=0.4)}
)
self._empty_luis_response: Dict[str, object] = json.loads(
'{ "query": null, "intents": [], "entities": [] }'
)
async def recognizer_internal(self, turn_context: TurnContext):
recognizer_result: RecognizerResult = None
utterance: str = turn_context.activity.text if turn_context.activity is not None else None
url = self._build_url()
body = self._build_request(utterance)
headers = {
"Ocp-Apim-Subscription-Key": self.luis_application.endpoint_key,
"Content-Type": "application/json",
}
async with aiohttp.ClientSession() as session:
async with session.post(
url, json=body, headers=headers, ssl=False
) as result:
luis_result = await result.json()
recognizer_result = RecognizerResult(
text=utterance,
intents=self._get_intents(luis_result["prediction"]),
entities=self._extract_entities_and_metadata(
luis_result["prediction"]
),
)
if self.luis_recognizer_options_v3.include_instance_data:
recognizer_result.entities[self._metadata_key] = (
recognizer_result.entities[self._metadata_key]
if self._metadata_key in recognizer_result.entities
else {}
)
if "sentiment" in luis_result["prediction"]:
recognizer_result.properties["sentiment"] = self._get_sentiment(
luis_result["prediction"]
)
await self._emit_trace_info(
turn_context,
luis_result,
recognizer_result,
self.luis_recognizer_options_v3,
)
return recognizer_result
async def recognizer_internal(self, turn_context: TurnContext):
utterance: str = turn_context.activity.text if turn_context.activity is not None else None
luis_result: LuisResult = self._runtime.prediction.resolve(
self._application.application_id,
utterance,
timezone_offset=self.luis_recognizer_options_v2.timezone_offset,
verbose=self.luis_recognizer_options_v2.include_all_intents,
staging=self.luis_recognizer_options_v2.staging,
spell_check=self.luis_recognizer_options_v2.spell_check,
bing_spell_check_subscription_key=self.luis_recognizer_options_v2.bing_spell_check_subscription_key,
log=self.luis_recognizer_options_v2.log
if self.luis_recognizer_options_v2.log is not None
else True,
)
recognizer_result: RecognizerResult = RecognizerResult(
text=utterance,
altered_text=luis_result.altered_query,
intents=LuisUtil.get_intents(luis_result),
entities=LuisUtil.extract_entities_and_metadata(
luis_result.entities,
luis_result.composite_entities,
self.luis_recognizer_options_v2.include_instance_data
if self.luis_recognizer_options_v2.include_instance_data is not None
else True,
),
)
LuisUtil.add_properties(luis_result, recognizer_result)
if self.luis_recognizer_options_v2.include_api_results:
recognizer_result.properties["luisResult"] = luis_result
await self._emit_trace_info(
turn_context,
luis_result,
recognizer_result,
self.luis_recognizer_options_v2,
)
return recognizer_result
async def _recognize_internal(
self,
turn_context: TurnContext,
telemetry_properties: Dict[str, str],
telemetry_metrics: Dict[str, float],
luis_prediction_options: Union[LuisPredictionOptions,
LuisRecognizerOptionsV2,
LuisRecognizerOptionsV3] = None,
) -> RecognizerResult:
BotAssert.context_not_none(turn_context)
if turn_context.activity.type != ActivityTypes.message:
return None
utterance: str = turn_context.activity.text if turn_context.activity is not None else None
recognizer_result: RecognizerResult = None
if luis_prediction_options:
options = luis_prediction_options
else:
options = self._options
if not utterance or utterance.isspace():
recognizer_result = RecognizerResult(
text=utterance,
intents={"": IntentScore(score=1.0)},
entities={})
else:
luis_recognizer = self._build_recognizer(options)
recognizer_result = await luis_recognizer.recognizer_internal(
turn_context)
# Log telemetry
self.on_recognizer_result(recognizer_result, turn_context,
telemetry_properties, telemetry_metrics)
return recognizer_result
def add_properties(luis: LuisResult, result: RecognizerResult) -> None:
if luis.sentiment_analysis is not None:
result.properties["sentiment"] = {
"label": luis.sentiment_analysis.label,
"score": luis.sentiment_analysis.score,
}
async def _recognize_internal(
self,
turn_context: TurnContext,
telemetry_properties: Dict[str, str],
telemetry_metrics: Dict[str, float],
luis_prediction_options: LuisPredictionOptions = None,
) -> RecognizerResult:
BotAssert.context_not_none(turn_context)
if turn_context.activity.type != ActivityTypes.message:
return None
utterance: str = turn_context.activity.text if turn_context.activity is not None else None
recognizer_result: RecognizerResult = None
luis_result: LuisResult = None
if luis_prediction_options:
options = self._merge_options(luis_prediction_options)
else:
options = self._options
if not utterance or utterance.isspace():
recognizer_result = RecognizerResult(
text=utterance,
intents={"": IntentScore(score=1.0)},
entities={})
else:
luis_result = self._runtime.prediction.resolve(
self._application.application_id,
utterance,
timezone_offset=options.timezone_offset,
verbose=options.include_all_intents,
staging=options.staging,
spell_check=options.spell_check,
bing_spell_check_subscription_key=options.
bing_spell_check_subscription_key,
log=options.log if options.log is not None else True,
)
recognizer_result = RecognizerResult(
text=utterance,
altered_text=luis_result.altered_query,
intents=LuisUtil.get_intents(luis_result),
entities=LuisUtil.extract_entities_and_metadata(
luis_result.entities,
luis_result.composite_entities,
options.include_instance_data
if options.include_instance_data is not None else True,
),
)
LuisUtil.add_properties(luis_result, recognizer_result)
if self._include_api_results:
recognizer_result.properties["luisResult"] = luis_result
# Log telemetry
self.on_recognizer_result(recognizer_result, turn_context,
telemetry_properties, telemetry_metrics)
await self._emit_trace_info(turn_context, luis_result,
recognizer_result, options)
return recognizer_result