Merge branch 'master' into trboehre/expectReplies

Author: tracyboehrer

libraries/botbuilder-ai/botbuilder/ai/luis/__init__.py

@@ -2,12 +2,14 @@
 # Licensed under the MIT License.
 
 from .luis_application import LuisApplication
+from .luis_recognizer_options_v3 import LuisRecognizerOptionsV3
 from .luis_prediction_options import LuisPredictionOptions
 from .luis_telemetry_constants import LuisTelemetryConstants
 from .luis_recognizer import LuisRecognizer
 
 __all__ = [
     "LuisApplication",
+    "LuisRecognizerOptionsV3",
     "LuisPredictionOptions",
     "LuisRecognizer",
     "LuisTelemetryConstants",

libraries/botbuilder-ai/botbuilder/ai/luis/luis_recognizer.py

@@ -3,11 +3,6 @@
 
 import json
 from typing import Dict, List, Tuple, Union
-
-from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
-from azure.cognitiveservices.language.luis.runtime.models import LuisResult
-from msrest.authentication import CognitiveServicesCredentials
-
 from botbuilder.core import (
     BotAssert,
     IntentScore,
@@ -16,10 +11,11 @@
     TurnContext,
 )
 from botbuilder.schema import ActivityTypes
-
 from . import LuisApplication, LuisPredictionOptions, LuisTelemetryConstants
-from .activity_util import ActivityUtil
-from .luis_util import LuisUtil
+from .luis_recognizer_v3 import LuisRecognizerV3
+from .luis_recognizer_v2 import LuisRecognizerV2
+from .luis_recognizer_options_v2 import LuisRecognizerOptionsV2
+from .luis_recognizer_options_v3 import LuisRecognizerOptionsV3
 
 
 class LuisRecognizer(Recognizer):
@@ -36,7 +32,9 @@ class LuisRecognizer(Recognizer):
     def __init__(
         self,
         application: Union[LuisApplication, str],
-        prediction_options: LuisPredictionOptions = None,
+        prediction_options: Union[
+            LuisRecognizerOptionsV2, LuisRecognizerOptionsV3, LuisPredictionOptions
+        ] = None,
         include_api_results: bool = False,
     ):
         """Initializes a new instance of the <see cref="LuisRecognizer"/> class.
@@ -59,17 +57,17 @@ def __init__(
             )
 
         self._options = prediction_options or LuisPredictionOptions()
-
-        self._include_api_results = include_api_results
+        self._include_api_results = include_api_results or (
+            prediction_options.include_api_results
+            if isinstance(
+                prediction_options, (LuisRecognizerOptionsV3, LuisRecognizerOptionsV2)
+            )
+            else False
+        )
 
         self.telemetry_client = self._options.telemetry_client
         self.log_personal_information = self._options.log_personal_information
 
-        credentials = CognitiveServicesCredentials(self._application.endpoint_key)
-        self._runtime = LUISRuntimeClient(self._application.endpoint, credentials)
-        self._runtime.config.add_user_agent(LuisUtil.get_user_agent())
-        self._runtime.config.connection.timeout = self._options.timeout // 1000
-
     @staticmethod
     def top_intent(
         results: RecognizerResult, default_intent: str = "None", min_score: float = 0.0
@@ -249,7 +247,9 @@ async def _recognize_internal(
         turn_context: TurnContext,
         telemetry_properties: Dict[str, str],
         telemetry_metrics: Dict[str, float],
-        luis_prediction_options: LuisPredictionOptions = None,
+        luis_prediction_options: Union[
+            LuisPredictionOptions, LuisRecognizerOptionsV2, LuisRecognizerOptionsV3
+        ] = None,
     ) -> RecognizerResult:
 
         BotAssert.context_not_none(turn_context)
@@ -259,10 +259,9 @@ async def _recognize_internal(
 
         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)
+            options = luis_prediction_options
         else:
             options = self._options
 
@@ -271,71 +270,49 @@ async def _recognize_internal(
                 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
+            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
         )
 
-        await self._emit_trace_info(
-            turn_context, luis_result, recognizer_result, options
-        )
-
         return recognizer_result
 
-    async def _emit_trace_info(
-        self,
-        turn_context: TurnContext,
-        luis_result: LuisResult,
-        recognizer_result: RecognizerResult,
-        options: LuisPredictionOptions,
-    ) -> None:
-        trace_info: Dict[str, object] = {
-            "recognizerResult": LuisUtil.recognizer_result_as_dict(recognizer_result),
-            "luisModel": {"ModelID": self._application.application_id},
-            "luisOptions": {"Staging": options.staging},
-            "luisResult": LuisUtil.luis_result_as_dict(luis_result),
-        }
-
-        trace_activity = ActivityUtil.create_trace(
-            turn_context.activity,
-            "LuisRecognizer",
-            trace_info,
-            LuisRecognizer.luis_trace_type,
-            LuisRecognizer.luis_trace_label,
-        )
-
-        await turn_context.send_activity(trace_activity)
-
     def _merge_options(
-        self, user_defined_options: LuisPredictionOptions
+        self,
+        user_defined_options: Union[
+            LuisRecognizerOptionsV3, LuisRecognizerOptionsV2, LuisPredictionOptions
+        ],
     ) -> LuisPredictionOptions:
         merged_options = LuisPredictionOptions()
         merged_options.__dict__.update(user_defined_options.__dict__)
         return merged_options
+
+    def _build_recognizer(
+        self,
+        luis_prediction_options: Union[
+            LuisRecognizerOptionsV3, LuisRecognizerOptionsV2, LuisPredictionOptions
+        ],
+    ):
+        if isinstance(luis_prediction_options, LuisRecognizerOptionsV3):
+            return LuisRecognizerV3(self._application, luis_prediction_options)
+        if isinstance(luis_prediction_options, LuisRecognizerOptionsV2):
+            return LuisRecognizerV3(self._application, luis_prediction_options)
+
+        recognizer_options = LuisRecognizerOptionsV2(
+            luis_prediction_options.bing_spell_check_subscription_key,
+            luis_prediction_options.include_all_intents,
+            luis_prediction_options.include_instance_data,
+            luis_prediction_options.log,
+            luis_prediction_options.spell_check,
+            luis_prediction_options.staging,
+            luis_prediction_options.timeout,
+            luis_prediction_options.timezone_offset,
+            self._include_api_results,
+            luis_prediction_options.telemetry_client,
+            luis_prediction_options.log_personal_information,
+        )
+        return LuisRecognizerV2(self._application, recognizer_options)

libraries/botbuilder-ai/botbuilder/ai/luis/luis_recognizer_internal.py

@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from abc import ABC, abstractmethod
+from botbuilder.core import TurnContext
+from .luis_application import LuisApplication
+
+
+class LuisRecognizerInternal(ABC):
+    def __init__(self, luis_application: LuisApplication):
+        if luis_application is None:
+            raise TypeError(luis_application.__class__.__name__)
+
+        self.luis_application = luis_application
+
+    @abstractmethod
+    async def recognizer_internal(self, turn_context: TurnContext):
+        raise NotImplementedError()

libraries/botbuilder-ai/botbuilder/ai/luis/luis_recognizer_options.py

@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from botbuilder.core import BotTelemetryClient, NullTelemetryClient
+
+
+class LuisRecognizerOptions:
+    def __init__(
+        self,
+        include_api_results: bool = None,
+        telemetry_client: BotTelemetryClient = NullTelemetryClient(),
+        log_personal_information: bool = False,
+    ):
+        self.include_api_results = include_api_results
+        self.telemetry_client = telemetry_client
+        self.log_personal_information = log_personal_information

libraries/botbuilder-ai/botbuilder/ai/luis/luis_recognizer_options_v2.py

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from botbuilder.core import BotTelemetryClient, NullTelemetryClient
+from .luis_recognizer_options import LuisRecognizerOptions
+
+
+class LuisRecognizerOptionsV2(LuisRecognizerOptions):
+    def __init__(
+        self,
+        bing_spell_check_subscription_key: str = None,
+        include_all_intents: bool = None,
+        include_instance_data: bool = True,
+        log: bool = True,
+        spell_check: bool = None,
+        staging: bool = None,
+        timeout: float = 100000,
+        timezone_offset: float = None,
+        include_api_results: bool = True,
+        telemetry_client: BotTelemetryClient = NullTelemetryClient(),
+        log_personal_information: bool = False,
+    ):
+        super().__init__(
+            include_api_results, telemetry_client, log_personal_information
+        )
+        self.bing_spell_check_subscription_key = bing_spell_check_subscription_key
+        self.include_all_intents = include_all_intents
+        self.include_instance_data = include_instance_data
+        self.log = log
+        self.spell_check = spell_check
+        self.staging = staging
+        self.timeout = timeout
+        self.timezone_offset = timezone_offset

libraries/botbuilder-ai/botbuilder/ai/luis/luis_recognizer_options_v3.py

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from typing import List
+
+from botbuilder.core import BotTelemetryClient, NullTelemetryClient
+from .luis_recognizer_options import LuisRecognizerOptions
+
+
+class LuisRecognizerOptionsV3(LuisRecognizerOptions):
+    def __init__(
+        self,
+        include_all_intents: bool = False,
+        include_instance_data: bool = True,
+        log: bool = True,
+        prefer_external_entities: bool = True,
+        datetime_reference: str = None,
+        dynamic_lists: List = None,
+        external_entities: List = None,
+        slot: str = "production",
+        version: str = None,
+        include_api_results: bool = True,
+        telemetry_client: BotTelemetryClient = NullTelemetryClient(),
+        log_personal_information: bool = False,
+    ):
+        super().__init__(
+            include_api_results, telemetry_client, log_personal_information
+        )
+        self.include_all_intents = include_all_intents
+        self.include_instance_data = include_instance_data
+        self.log = log
+        self.prefer_external_entities = prefer_external_entities
+        self.datetime_reference = datetime_reference
+        self.dynamic_lists = dynamic_lists
+        self.external_entities = external_entities
+        self.slot = slot
+        self.version: str = version