rasa-pro 3.9.18__py3-none-any.whl

rasa/dialogue_understanding/stack/utils.py

@@ -0,0 +1,211 @@
+from typing import List, Optional, Set, Tuple
+import typing
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames import BaseFlowStackFrame
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
+from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
+from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.flows.steps.constants import END_STEP
+from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
+from rasa.shared.core.flows import FlowsList
+
+if typing.TYPE_CHECKING:
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+def top_flow_frame(
+    dialogue_stack: DialogueStack,
+    ignore_collect_information_pattern: bool = True,
+    ignore_call_frames: bool = True,
+) -> Optional[BaseFlowStackFrame]:
+    """Returns the topmost flow frame from the tracker.
+
+    By default, the topmost flow frame is ignored if it is the
+    `pattern_collect_information`. This is because the `pattern_collect_information`
+    is a special flow frame that is used to collect information from the user
+    and commonly, is not what you are looking for when you want the topmost frame.
+
+    Also excludes frames created by a call step. They are treated as if they are
+    directly part of the flow that called them.
+
+    Args:
+        dialogue_stack: The dialogue stack to use.
+        ignore_collect_information_pattern: Whether to ignore the
+            `pattern_collect_information` frame.
+        ignore_call_frames: Whether to ignore user frames of type `call`
+
+    Returns:
+        The topmost flow frame from the tracker. `None` if there
+        is no frame on the stack.
+    """
+    for frame in reversed(dialogue_stack.frames):
+        if ignore_collect_information_pattern and isinstance(
+            frame, CollectInformationPatternFlowStackFrame
+        ):
+            continue
+        if ignore_call_frames and (
+            isinstance(frame, UserFlowStackFrame)
+            and frame.frame_type == FlowStackFrameType.CALL
+        ):
+            continue
+        if isinstance(frame, BaseFlowStackFrame):
+            return frame
+    return None
+
+
+def top_user_flow_frame(dialogue_stack: DialogueStack) -> Optional[UserFlowStackFrame]:
+    """Returns the topmost user flow frame from the tracker.
+
+    User flows are flows that are created by developers of an assistant and
+    describe tasks the assistant can fulfil. The topmost user flow frame is
+    the topmost frame on the stack for one of these user flows. While looking
+    for this topmost user flow, other frame types such as PatternFrames,
+    SearchFrames, ChitchatFrames, and user flows started through call steps
+    are skipped. The latter are treated as part of the calling user flow.
+
+    Args:
+        dialogue_stack: The dialogue stack to use.
+
+    Returns:
+    The topmost user flow frame from the tracker.
+    """
+    for frame in reversed(dialogue_stack.frames):
+        if (
+            isinstance(frame, UserFlowStackFrame)
+            and frame.frame_type != FlowStackFrameType.CALL
+        ):
+            return frame
+    return None
+
+
+def filled_slots_for_active_flow(
+    tracker: "DialogueStateTracker", all_flows: FlowsList
+) -> Tuple[Set[str], Optional[str]]:
+    """Get all slots that have been filled for the 'current user flow'.
+
+    All patterns that sit ontop of that user flow as well as
+    flows called by this flow, are also included.
+
+    Any collect information step that is part of a pattern on top of the current
+    user flow are also included.
+
+    Args:
+        tracker: The tracker to get the filled slots from.
+        all_flows: All flows.
+
+    Returns:
+    All slots that have been filled for the current flow and the id of the currently
+    active flow.
+    """
+    stack = tracker.stack
+    user_frame = top_user_flow_frame(stack)
+    active_flow = user_frame.flow_id if user_frame else None
+
+    filled_slots = set()
+    for collect_step, _ in previous_collect_steps_for_active_flow(tracker, all_flows):
+        filled_slots.add(collect_step.collect)
+
+    return filled_slots, active_flow
+
+
+def previous_collect_steps_for_active_flow(
+    tracker: "DialogueStateTracker", all_flows: FlowsList
+) -> List[Tuple[CollectInformationFlowStep, str]]:
+    stack = tracker.stack
+    user_frame = top_user_flow_frame(stack)
+
+    if not user_frame:
+        return []
+
+    collect_steps: List[Tuple[CollectInformationFlowStep, str]] = []
+
+    active_frames = {frame.frame_id for frame in stack.frames}
+
+    for previous_stack in tracker.previous_stack_states():
+        active_frame = top_user_flow_frame(previous_stack)
+        if not active_frame or active_frame.frame_id != user_frame.frame_id:
+            continue
+
+        top_frame = previous_stack.top()
+        if not isinstance(top_frame, BaseFlowStackFrame):
+            continue
+
+        step = top_frame.step(all_flows)
+        if not isinstance(step, CollectInformationFlowStep):
+            continue
+
+        if isinstance(top_frame, UserFlowStackFrame):
+            collect_steps.append((step, top_frame.flow_id))
+        elif (
+            isinstance(top_frame, PatternFlowStackFrame)
+            and top_frame.frame_id in active_frames
+        ):
+            # if this is a pattern, it is only relevant if it is still
+            # active in the current state of the conversation.
+            # completed patterns in the past are not relevant
+            collect_steps.append((step, top_frame.flow_id))
+
+    return collect_steps
+
+
+def user_flows_on_the_stack(dialogue_stack: DialogueStack) -> Set[str]:
+    """Get all user flows that are currently on the stack.
+
+    Args:
+        dialogue_stack: The dialogue stack.
+
+    Returns:
+    All user flows that are currently on the stack.
+    """
+    return {
+        f.flow_id for f in dialogue_stack.frames if isinstance(f, UserFlowStackFrame)
+    }
+
+
+def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
+    """Ends all frames on top of the stack including the topmost user frame.
+
+    Ends all flows until the next user flow is reached. This is useful
+    if you want to end all flows that are currently on the stack and
+    the user flow that triggered them.
+
+    Args:
+        stack: The dialogue stack.
+    """
+    updated_stack = stack.copy()
+
+    for frame in reversed(updated_stack.frames):
+        if isinstance(frame, BaseFlowStackFrame):
+            frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+            if isinstance(frame, UserFlowStackFrame):
+                break
+    return updated_stack
+
+
+def get_collect_steps_excluding_ask_before_filling_for_active_flow(
+    dialogue_stack: DialogueStack, all_flows: FlowsList
+) -> Set[str]:
+    """Get all collect steps that are part of the current flow, without
+    considering the collect steps that has to be asked before filling.
+
+    Args:
+        dialogue_stack: The dialogue stack.
+        all_flows: All flows.
+
+    Returns:
+        All collect steps that are part of the current active flow,
+        excluding the collect steps that have to be asked before filling.
+    """
+    active_frame = top_user_flow_frame(dialogue_stack)
+    if active_frame is None:
+        return set()
+    active_flow = active_frame.flow(all_flows)
+    return set(
+        step.collect
+        for step in active_flow.get_collect_steps()
+        if not step.ask_before_filling
+    )

rasa/e2e_test/constants.py

@@ -0,0 +1,11 @@
+SCHEMA_FILE_PATH = "e2e_test/e2e_test_schema.yml"
+
+KEY_FIXTURES = "fixtures"
+KEY_USER_INPUT = "user"
+KEY_BOT_INPUT = "bot"
+KEY_BOT_UTTERED = "utter"
+KEY_SLOT_SET = "slot_was_set"
+KEY_SLOT_NOT_SET = "slot_was_not_set"
+KEY_STEPS = "steps"
+KEY_TEST_CASE = "test_case"
+KEY_METADATA = "metadata"

rasa/e2e_test/e2e_test_case.py

@@ -0,0 +1,366 @@
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Text, Union
+
+from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
+
+from rasa.e2e_test.constants import (
+    KEY_BOT_INPUT,
+    KEY_BOT_UTTERED,
+    KEY_FIXTURES,
+    KEY_METADATA,
+    KEY_SLOT_NOT_SET,
+    KEY_SLOT_SET,
+    KEY_STEPS,
+    KEY_TEST_CASE,
+    KEY_USER_INPUT,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Fixture:
+    """Class for storing an input fixture."""
+
+    name: Text
+    slots_set: Dict[Text, Any]
+
+    @staticmethod
+    def from_dict(fixture_dict: Dict[Text, Any]) -> "Fixture":
+        """Creates a fixture from a dictionary.
+
+        Example:
+            >>> Fixture.from_dict({"some_fixture": [{"slot_name": "slot_value"}]})
+            Fixture(name="some_fixture", slots_set={"slot_name": "slot_value"})
+
+        Args:
+            fixture_dict: Dictionary containing the fixture.
+        """
+        return Fixture(
+            name=next(iter(fixture_dict.keys())),
+            slots_set={
+                slot_name: slot_value
+                for slots_list in fixture_dict.values()
+                for slot_dict in slots_list
+                for slot_name, slot_value in slot_dict.items()
+            },
+        )
+
+
+@dataclass(frozen=True)
+class TestStep:
+    """Class for storing the input test step.
+
+    Instances are frozen to make sure the underlying dictionary stays in sync
+    with the text and actor attributes.
+    """
+
+    actor: Text
+    text: Optional[Text] = None
+    template: Optional[Text] = None
+    line: Optional[int] = None
+    slot_was_set: bool = False
+    slot_was_not_set: bool = False
+    _slot_instance: Optional[Union[Text, Dict[Text, Any]]] = None
+    _underlying: Optional[Dict[Text, Any]] = None
+    metadata_name: Optional[Text] = None
+
+    @staticmethod
+    def from_dict(test_step_dict: Dict[Text, Any]) -> "TestStep":
+        """Creates a test step from a dictionary.
+
+        Example:
+            >>> TestStep.from_dict({"user": "hello"})
+            TestStep(text="hello", actor="user")
+            >>> TestStep.from_dict({"user": "hello", metadata: "some_metadata"})
+            TestStep(text="hello", actor="user", metadata_name="some_metadata")
+            >>> TestStep.from_dict({"bot": "hello world"})
+            TestStep(text="hello world", actor="bot")
+
+        Args:
+            test_step_dict: Dictionary containing the test step.
+        """
+        TestStep._validate_input_dict(test_step_dict)
+        slot_instance = test_step_dict.get(KEY_SLOT_SET)
+        if test_step_dict.get(KEY_SLOT_NOT_SET):
+            slot_instance = test_step_dict.get(KEY_SLOT_NOT_SET)
+
+        return TestStep(
+            text=test_step_dict.get(
+                KEY_USER_INPUT, test_step_dict.get(KEY_BOT_INPUT, "")
+            ).strip()
+            or None,
+            template=test_step_dict.get(KEY_BOT_UTTERED),
+            actor=KEY_USER_INPUT if KEY_USER_INPUT in test_step_dict else KEY_BOT_INPUT,
+            line=test_step_dict.lc.line + 1 if hasattr(test_step_dict, "lc") else None,
+            slot_was_set=bool(test_step_dict.get(KEY_SLOT_SET)),
+            slot_was_not_set=bool(test_step_dict.get(KEY_SLOT_NOT_SET)),
+            _slot_instance=slot_instance,
+            _underlying=test_step_dict,
+            metadata_name=test_step_dict.get(KEY_METADATA, ""),
+        )
+
+    @staticmethod
+    def _validate_input_dict(test_step_dict: Dict[Text, Any]) -> None:
+        if (
+            KEY_USER_INPUT not in test_step_dict
+            and KEY_BOT_INPUT not in test_step_dict
+            and KEY_BOT_UTTERED not in test_step_dict
+            and KEY_SLOT_SET not in test_step_dict
+            and KEY_SLOT_NOT_SET not in test_step_dict
+        ):
+            raise ValueError(
+                f"Test step is missing either the {KEY_USER_INPUT}, {KEY_BOT_INPUT}, "
+                f"{KEY_SLOT_NOT_SET}, {KEY_SLOT_SET} "
+                f"or {KEY_BOT_UTTERED} key: {test_step_dict}"
+            )
+
+        if (
+            test_step_dict.get(KEY_SLOT_SET) is not None
+            and test_step_dict.get(KEY_SLOT_NOT_SET) is not None
+        ):
+            raise ValueError(
+                f"Test step has both {KEY_SLOT_SET} and {KEY_SLOT_NOT_SET} keys: "
+                f"{test_step_dict}. You must only use one of the keys in a test step."
+            )
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Returns the underlying dictionary of the test step."""
+        return self._underlying or {}
+
+    def matches_event(self, other: Union[BotUttered, SlotSet, None]) -> bool:
+        """Compares the test step with BotUttered or SlotSet event.
+
+        Args:
+            other: BotUttered or SlotSet event to compare with.
+
+        Returns:
+            `True` if the event and step match, `False` otherwise.
+        """
+        if other is None or self.actor != "bot":
+            return False
+
+        if isinstance(other, BotUttered):
+            return self._do_utterances_match(other)
+        elif isinstance(other, SlotSet):
+            return self._do_slots_match(other)
+
+        return False
+
+    def _do_utterances_match(self, other: BotUttered) -> bool:
+        if self.text:
+            return other.text == self.text
+        elif self.template:
+            # we do set this utter_action metadata in the `ActionBotResponse`
+            # action, so we can check if the template is the same
+            return other.metadata.get("utter_action") == self.template
+
+        return False
+
+    def _do_slots_match(self, other: SlotSet) -> bool:
+        if self._slot_instance:
+            slot_name, slot_value = self.get_slot_name(), self.get_slot_value()
+            if isinstance(self._slot_instance, dict):
+                return other.key == slot_name and other.value == slot_value
+            return other.key == slot_name
+
+        return False
+
+    def get_slot_name(self) -> Optional[Text]:
+        """Returns the slot name if the test step is a slot action."""
+        if isinstance(self._slot_instance, str):
+            return self._slot_instance
+        if isinstance(self._slot_instance, dict):
+            return next(iter(self._slot_instance.keys()))
+        return None
+
+    def get_slot_value(self) -> Optional[Any]:
+        """Returns the slot value if the test step is a slot action."""
+        if isinstance(self._slot_instance, dict):
+            return next(iter(self._slot_instance.values()))
+        return None
+
+    def is_slot_instance_dict(self) -> bool:
+        """Asserts if the slot instance is a dictionary."""
+        return isinstance(self._slot_instance, dict)
+
+
+@dataclass
+class ActualStepOutput:
+    """Class for storing the events that are generated as a response from the bot."""
+
+    actor: Text
+    text: Optional[Text]
+    events: List[Union[BotUttered, UserUttered, SlotSet]]
+    bot_uttered_events: List[BotUttered]
+    user_uttered_events: List[UserUttered]
+    slot_set_events: List[SlotSet]
+
+    @staticmethod
+    def from_test_step(
+        test_step: TestStep,
+        events: List[Union[BotUttered, UserUttered, SlotSet]],
+    ) -> "ActualStepOutput":
+        """Creates a test step response from a test step and events.
+
+        Example:
+            >>> ActualStepOutput.from_test_step(TestStep(text="hello", actor="bot"))
+            ActualStepOutput(text="hello", actor="bot")
+
+        Args:
+            test_step: Test step.
+            events: Events generated by the bot.
+        """
+        bot_uttered_events, user_uttered_events, slot_set_events = [], [], []
+        for event in events or []:
+            if isinstance(event, BotUttered):
+                bot_uttered_events.append(event)
+            elif isinstance(event, UserUttered):
+                user_uttered_events.append(event)
+            elif isinstance(event, SlotSet):
+                slot_set_events.append(event)
+
+        return ActualStepOutput(
+            text=test_step.text,
+            actor=test_step.actor,
+            events=events,
+            bot_uttered_events=bot_uttered_events,
+            user_uttered_events=user_uttered_events,
+            slot_set_events=slot_set_events,
+        )
+
+    def remove_bot_uttered_event(self, bot_utter: BotUttered) -> None:
+        """Removes bot_uttered_event from the ActualStepOutput."""
+        if bot_utter in self.bot_uttered_events:
+            self.bot_uttered_events.remove(bot_utter)
+            self.events.remove(bot_utter)
+
+    def remove_user_uttered_event(self, user_utter: UserUttered) -> None:
+        """Removes user_uttered_event from the ActualStepOutput."""
+        if user_utter in self.user_uttered_events:
+            self.user_uttered_events.remove(user_utter)
+            self.events.remove(user_utter)
+
+    def remove_slot_set_event(self, slot_set: SlotSet) -> None:
+        """Removes slot_set_event from the ActualStepOutput."""
+        if slot_set in self.slot_set_events:
+            self.slot_set_events.remove(slot_set)
+            self.events.remove(slot_set)
+
+    def get_user_uttered_event(self) -> Optional[UserUttered]:
+        """Returns the user_uttered_event from the ActualStepOutput."""
+        if self.user_uttered_events:
+            # we assume that there is only one user_uttered_event
+            # in the ActualStepOutput since the response is
+            # only from one TestStep with one user utterance
+            try:
+                return self.user_uttered_events[0]
+            except IndexError:
+                logger.debug(
+                    f"Could not find `UserUttered` event in the ActualStepOutput: "
+                    f"{self}"
+                )
+                return None
+        return None
+
+
+@dataclass
+class TestCase:
+    """Class for storing the input test case."""
+
+    name: Text
+    steps: List[TestStep]
+    file: Optional[Text] = None
+    line: Optional[int] = None
+    fixture_names: Optional[List[Text]] = None
+    metadata_name: Optional[Text] = None
+
+    @staticmethod
+    def from_dict(
+        input_test_case: Dict[Text, Any], file: Optional[Text] = None
+    ) -> "TestCase":
+        """Creates a test case from a dictionary.
+
+        Example:
+            >>> TestCase.from_dict({"test_case": "test", "steps": [{"user": "hello"}]})
+            TestCase(name="test", steps=[TestStep(text="hello", actor="user")])
+
+        Args:
+            input_test_case: Dictionary containing the test case.
+            file: File name of the test case.
+
+        Returns:
+            Test case object.
+        """
+        steps = []
+
+        for step in input_test_case.get(KEY_STEPS, []):
+            if KEY_SLOT_SET in step:
+                for slot in step[KEY_SLOT_SET]:
+                    step_copy = step.copy()
+                    step_copy[KEY_SLOT_SET] = slot
+                    steps.append(TestStep.from_dict(step_copy))
+            elif KEY_SLOT_NOT_SET in step:
+                for slot in step[KEY_SLOT_NOT_SET]:
+                    step_copy = step.copy()
+                    step_copy[KEY_SLOT_NOT_SET] = slot
+                    steps.append(TestStep.from_dict(step_copy))
+            else:
+                steps.append(TestStep.from_dict(step))
+
+        return TestCase(
+            name=input_test_case.get(KEY_TEST_CASE, "default"),
+            steps=steps,
+            file=file,
+            line=input_test_case.lc.line + 1
+            if hasattr(input_test_case, "lc")
+            else None,
+            fixture_names=input_test_case.get(KEY_FIXTURES),
+            metadata_name=input_test_case.get(KEY_METADATA),
+        )
+
+    def file_with_line(self) -> Text:
+        """Returns the file name and line number of the test case."""
+        if not self.file:
+            return ""
+
+        line = str(self.line) if self.line is not None else ""
+        return f"{self.file}:{line}"
+
+
+@dataclass(frozen=True)
+class Metadata:
+    """Class for storing an input metadata."""
+
+    name: Text
+    metadata: Dict[Text, Any]
+
+    @staticmethod
+    def from_dict(metadata_dict: Dict[Text, Any]) -> "Metadata":
+        """Creates a metadata from a dictionary.
+
+        Example:
+            >>> Metadata.from_dict({"some_metadata": {"room": "test_room"}})
+            Metadata(name="some_metadata", metadata={"room": "test_room"})
+
+        Args:
+            metadata_dict: Dictionary containing the metadata.
+        """
+        return Metadata(
+            name=next(iter(metadata_dict.keys())),
+            metadata={
+                metadata_name: metadata_value
+                for metadata in metadata_dict.values()
+                for metadata_name, metadata_value in metadata.items()
+            },
+        )
+
+
+@dataclass(frozen=True)
+class TestSuite:
+    """Class for representing all top level test suite keys."""
+
+    test_cases: List[TestCase]
+    fixtures: List[Fixture]
+    metadata: List[Metadata]

rasa/e2e_test/e2e_test_result.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Text
+
+from rasa.e2e_test.e2e_test_case import TestCase
+
+NO_RESPONSE = "* No Bot Response *"
+NO_SLOT = "* No Slot Set *"
+
+
+@dataclass
+class TestResult:
+    """Class for storing results of every test case run."""
+
+    test_case: TestCase
+    pass_status: bool
+    difference: List[Text]
+    error_line: Optional[int] = None
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Returns the test result as a dictionary."""
+        return {
+            "name": self.test_case.name,
+            "pass_status": self.pass_status,
+            "expected_steps": [s.as_dict() for s in self.test_case.steps],
+            "difference": self.difference,
+        }
+
+
+@dataclass
+class TestFailure:
+    """Class for storing the test case failure."""
+
+    test_case: TestCase
+    error_line: Optional[int]