Zerryth/dialog prompts

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-core/botbuilder/core/turn_context.py

@@ -140,7 +140,8 @@ async def send_activity(self, *activity_or_text: Union[Activity, str]) -> Resour
             Activity(text=a, type='message') if isinstance(a, str) else a, reference)
             for a in activity_or_text]
         for activity in output:
-            activity.input_hint = 'acceptingInput'
+            if not activity.input_hint:
+                activity.input_hint = 'acceptingInput'
 
         async def callback(context: 'TurnContext', output):
             responses = await context.adapter.send_activities(context, output)

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

@@ -9,6 +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", "ListStyle"]
+__all__ = [
+    "Channel",
+    "Choice",
+    "ChoiceFactory",
+    "ChoiceFactoryOptions",
+    "ChoiceRecognizers",
+    "Find",
+    "FindChoicesOptions",
+    "FindValuesOptions",
+    "FoundChoice",
+    "ListStyle",
+    "ModelResult",
+    "SortedValue",
+    "Token",
+    "Tokenizer"
+]

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

@@ -7,7 +7,7 @@
 
 class Channel(object):
     """
-    Methods for determining channel specific functionality.
+    Methods for determining channel-specific functionality.
     """
 
     @staticmethod

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

@@ -10,6 +10,9 @@
 
 
 class ChoiceFactory:
+    """
+    Assists with formatting a message activity that contains a list of choices.
+    """
     @staticmethod
     def for_channel(
         channel_id: str,
@@ -18,6 +21,20 @@ def for_channel(
         speak: str = None,
         options: ChoiceFactoryOptions = None,
     ) -> Activity:
+        """
+        Creates a message activity that includes a list of choices formatted based on the capabilities of a given channel.
+
+        Parameters:
+        ----------
+
+        channel_id: A channel ID. 
+
+        choices: List of choices to render.
+
+        text: (Optional) Text of the message to send.
+
+        speak (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel.
+        """
         if channel_id is None:
             channel_id = ""
 
@@ -65,6 +82,20 @@ def inline(
         speak: str = None,
         options: ChoiceFactoryOptions = None,
     ) -> Activity:
+        """
+        Creates a message activity that includes a list of choices formatted as an inline list.
+
+        Parameters:
+        ----------
+
+        choices: The list of choices to render.
+
+        text: (Optional) The text of the message to send.
+
+        speak: (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel.
+
+        options: (Optional) The formatting options to use to tweak rendering of list.
+        """
         if choices is None:
             choices = []
 
@@ -113,6 +144,20 @@ def list_style(
         speak: str = None,
         options: ChoiceFactoryOptions = None,
     ):
+        """
+        Creates a message activity that includes a list of choices formatted as a numbered or bulleted list.
+
+        Parameters:
+        ----------
+
+        choices: The list of choices to render.
+
+        text: (Optional) The text of the message to send.
+
+        speak: (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel.
+
+        options: (Optional) The formatting options to use to tweak rendering of list.
+        """
         if choices is None:
             choices = []
         if options is None:
@@ -153,6 +198,9 @@ def list_style(
     def suggested_action(
         choices: List[Choice], text: str = None, speak: str = None
     ) -> Activity:
+        """
+        Creates a message activity that includes a list of choices that have been added as suggested actions.
+        """
         # Return activity with choices as suggested actions
         return MessageFactory.suggested_actions(
             ChoiceFactory._extract_actions(choices),
@@ -165,6 +213,9 @@ def suggested_action(
     def hero_card(
         choices: List[Choice], text: str = None, speak: str = None
     ) -> Activity:
+        """
+        Creates a message activity that includes a lsit of coices that have been added as `HeroCard`'s
+        """
         attachment = CardFactory.hero_card(
             HeroCard(text=text, buttons=ChoiceFactory._extract_actions(choices))
         )
@@ -176,6 +227,9 @@ def hero_card(
 
     @staticmethod
     def _to_choices(choices: List[str]) -> List[Choice]:
+        """
+        Takes a list of strings and returns them as [`Choice`].
+        """
         if choices is None:
             return []
         else:

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

@@ -0,0 +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. """
+
+    @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 is None:
+            utterance = ''
+
+        # Normalize list of choices
+        choices_list = [Choice(value=choice) if isinstance(choice, str) else choice for choice in choices]
+
+        # 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,
+            )
+        )
+
+