Solved merge conflicts with master

Author: axelsrz

libraries/botbuilder-core/botbuilder/core/adapters/test_adapter.py

@@ -134,7 +134,7 @@ async def receive_activity(self, activity):
             if value is not None and key != 'additional_properties':
                 setattr(request, key, value)
 
-            request.type = ActivityTypes.message
+        request.type = request.type or ActivityTypes.message
         if not request.id:
             self._next_id += 1
             request.id = str(self._next_id)
@@ -143,6 +143,9 @@ async def receive_activity(self, activity):
         context = TurnContext(self, request)
         return await self.run_pipeline(context, self.logic)
 
+    def get_next_activity(self) -> Activity:
+        return self.activity_buffer.pop(0)
+
     async def send(self, user_says) -> object:
         """
         Sends something to the bot. This returns a new `TestFlow` instance which can be used to add
@@ -300,7 +303,7 @@ def default_inspector(reply, description=None):
                 validate_activity(reply, expected)
             else:
                 assert reply.type == 'message', description + f" type == {reply.type}"
-                assert reply.text == expected, description + f" text == {reply.text}"
+                assert reply.text.strip() == expected.strip(), description + f" text == {reply.text}"
 
         if description is None:
             description = ''

libraries/botbuilder-dialogs/botbuilder/dialogs/choices/__init__.py

@@ -9,23 +9,30 @@
 from .choice import Choice
 from .choice_factory_options import ChoiceFactoryOptions
 from .choice_factory import ChoiceFactory
+from .choice_recognizers import ChoiceRecognizers
+from .find import Find
 from .find_choices_options import FindChoicesOptions, FindValuesOptions
 from .found_choice import FoundChoice
+from .found_value import FoundValue
 from .list_style import ListStyle
 from .model_result import ModelResult
 from .sorted_value import SortedValue
 from .token import Token
+from .tokenizer import Tokenizer
 
 __all__ = [
     "Channel",
     "Choice",
     "ChoiceFactory",
     "ChoiceFactoryOptions",
+    "ChoiceRecognizers",
+    "Find",
     "FindChoicesOptions",
     "FindValuesOptions",
     "FoundChoice",
     "ListStyle",
     "ModelResult",
     "SortedValue",
-    "Token"
+    "Token",
+    "Tokenizer"
 ]

libraries/botbuilder-dialogs/botbuilder/dialogs/choices/choice_recognizers.py

@@ -1,15 +1,137 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
+from recognizers_number import NumberModel, NumberRecognizer, OrdinalModel
+from recognizers_text import Culture
+from typing import List, Union
+
+
+from .choice import Choice
+from .find import Find
+from .find_choices_options import FindChoicesOptions
+from .found_choice import FoundChoice
+from .model_result import ModelResult
+
 class ChoiceRecognizers:
     """ Contains methods for matching user input against a list of choices. """
 
-    # Note to self: C# implementation has 2 RecognizeChoices overloads, different in their list parameter
-    # 1. list of strings - that gets converted into a list of Choice's
-    # 2. list of choices
-    # Looks like in TS the implement also allows for either string[] or Choice[]
+    @staticmethod
+    def recognize_choices(
+            utterance: str,
+            choices: List[Union[str, Choice]],
+            options: FindChoicesOptions = None
+    ) -> List[ModelResult]:
+        """
+        Matches user input against a list of choices.
+
+        This is layered above the `Find.find_choices()` function, and adds logic to let the user specify
+        their choice by index (they can say "one" to pick `choice[0]`) or ordinal position (they can say "the second one" to pick `choice[1]`.)
+        The user's utterance is recognized in the following order:
+
+        - By name using `find_choices()`
+        - By 1's based ordinal position.
+        - By 1's based index position.
+
+        Parameters:
+        -----------
+
+        utterance: The input.
+        
+        choices: The list of choices.
+
+        options: (Optional) Options to control the recognition strategy.
+
+        Returns:
+        --------
+        A list of found choices, sorted by most relevant first.
+        """
+        if utterance == None:
+            utterance = ''
+        
+        # Normalize list of choices
+        choices_list = [Choice(value=choice) if isinstance(choice, str) else choice for choice in choices]
 
-    # C# none of the functions seem to be nested inside another function
-    # TS has only 1 recognizer funtion, recognizeChoices()
-        # nested within recognizeChoices() is matchChoiceByIndex()
+        # Try finding choices by text search first
+        # - We only want to use a single strategy for returning results to avoid issues where utterances
+        #   like the "the third one" or "the red one" or "the first division book" would miss-recognize as
+        #   a numerical index or ordinal as well.
+        locale = options.locale if (options and options.locale) else Culture.English
+        matched = Find.find_choices(utterance, choices_list, options)
+        if len(matched) == 0:
+            # Next try finding by ordinal
+            matches =  ChoiceRecognizers._recognize_ordinal(utterance, locale)
+            
+            if len(matches) > 0:
+                for match in matches:
+                    ChoiceRecognizers._match_choice_by_index(choices_list, matched, match)
+            else:
+                # Finally try by numerical index
+                matches = ChoiceRecognizers._recognize_number(utterance, locale)
+
+                for match in matches:
+                    ChoiceRecognizers._match_choice_by_index(choices_list, matched, match)
+            
+            # Sort any found matches by their position within the utterance.
+            # - The results from find_choices() are already properly sorted so we just need this
+            #   for ordinal & numerical lookups.
+            matched = sorted(
+                matched,
+                key=lambda model_result: model_result.start
+            )
+        
+        return matched
+                
+
+    @staticmethod
+    def _recognize_ordinal(utterance: str, culture: str) -> List[ModelResult]:
+        model: OrdinalModel = NumberRecognizer(culture).get_ordinal_model(culture)
+
+        return list(map(ChoiceRecognizers._found_choice_constructor, model.parse(utterance)))
+    
+    @staticmethod
+    def _match_choice_by_index(
+            choices: List[Choice],
+            matched: List[ModelResult],
+            match: ModelResult
+    ):
+        try:
+            index: int = int(match.resolution.value) - 1
+            if (index >= 0 and index < len(choices)):
+                choice = choices[index]
+
+                matched.append(ModelResult(
+                    start=match.start,
+                    end=match.end,
+                    type_name='choice',
+                    text=match.text,
+                    resolution=FoundChoice(
+                        value=choice.value,
+                        index=index,
+                        score=1.0
+                    )
+                ))
+        except:
+            # noop here, as in dotnet/node repos
+            pass
+    
+    @staticmethod
+    def _recognize_number(utterance: str, culture: str) -> List[ModelResult]:
+        model: NumberModel = NumberRecognizer(culture).get_number_model(culture)
+
+        return list(map(ChoiceRecognizers._found_choice_constructor, model.parse(utterance)))
 
+    @staticmethod
+    def _found_choice_constructor(value_model: ModelResult) -> ModelResult:
+        return ModelResult(
+            start=value_model.start,
+            end=value_model.end,
+            type_name='choice',
+            text=value_model.text,
+            resolution=FoundChoice(
+                value=value_model.resolution['value'],
+                index=0,
+                score=1.0,
+            )
+        )
+
+