rasa-pro 3.9.18__py3-none-any.whl → 3.10.16__py3-none-any.whl

rasa/dialogue_understanding/patterns/restart.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_RESTART = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "restart"
+
+
+@dataclass
+class RestartPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added at the beginning of the conversation."""
+
+    flow_id: str = FLOW_PATTERN_RESTART
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_RESTART
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> RestartPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return RestartPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/session_start.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_SESSION_START = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "session_start"
+
+
+@dataclass
+class SessionStartPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added at the beginning of the conversation."""
+
+    flow_id: str = FLOW_PATTERN_SESSION_START
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SESSION_START
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SessionStartPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SessionStartPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/processor/command_processor.py

@@ -1,6 +1,7 @@
 from typing import List, Optional, Type, Set, Dict
 
 import structlog
+from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     ClarifyCommand,
@@ -179,6 +180,7 @@ def execute_commands(
     tracker: DialogueStateTracker,
     all_flows: FlowsList,
     execution_context: ExecutionContext,
+    story_graph: Optional[StoryGraph] = None,
 ) -> List[Event]:
     """Executes a list of commands.
 
@@ -187,6 +189,7 @@ def execute_commands(
         tracker: The tracker to execute the commands on.
         all_flows: All flows.
         execution_context: Information about the single graph run.
+        story_graph: StoryGraph object with stories available for training.
 
     Returns:
         A list of the events that were created.
@@ -194,7 +197,9 @@ def execute_commands(
     commands: List[Command] = get_commands_from_tracker(tracker)
     original_tracker = tracker.copy()
 
-    commands = clean_up_commands(commands, tracker, all_flows, execution_context)
+    commands = clean_up_commands(
+        commands, tracker, all_flows, execution_context, story_graph
+    )
 
     updated_flows = find_updated_flows(tracker, all_flows)
     if updated_flows:
@@ -326,6 +331,7 @@ def clean_up_commands(
     tracker: DialogueStateTracker,
     all_flows: FlowsList,
     execution_context: ExecutionContext,
+    story_graph: Optional[StoryGraph] = None,
 ) -> List[Command]:
     """Clean up a list of commands.
 
@@ -340,6 +346,7 @@ def clean_up_commands(
         tracker: The tracker to clean up the commands for.
         all_flows: All flows.
         execution_context: Information about a single graph run.
+        story_graph: StoryGraph object with stories available for training.
 
     Returns:
     The cleaned up commands.
@@ -386,7 +393,7 @@ def clean_up_commands(
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
             clean_commands = clean_up_chitchat_command(
-                clean_commands, command, all_flows, execution_context
+                clean_commands, command, all_flows, execution_context, story_graph
             )
 
         elif isinstance(command, FreeFormAnswerCommand):
@@ -563,6 +570,7 @@ def clean_up_chitchat_command(
     command: ChitChatAnswerCommand,
     flows: FlowsList,
     execution_context: ExecutionContext,
+    story_graph: Optional[StoryGraph] = None,
 ) -> List[Command]:
     """Clean up a chitchat answer command.
 
@@ -574,6 +582,7 @@ def clean_up_chitchat_command(
         command: The command to clean up.
         flows: All flows.
         execution_context: Information about a single graph run.
+        story_graph: StoryGraph object with stories available for training.
     Returns:
         The cleaned up commands.
     """
@@ -599,7 +608,11 @@ def clean_up_chitchat_command(
     )
     defines_intentless_policy = execution_context.has_node(IntentlessPolicy)
 
-    if has_action_trigger_chitchat and not defines_intentless_policy:
+    has_e2e_stories = True if (story_graph and story_graph.has_e2e_stories()) else False
+
+    if (has_action_trigger_chitchat and not defines_intentless_policy) or (
+        defines_intentless_policy and not has_e2e_stories
+    ):
         resulting_commands.insert(
             0, CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)
         )

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -9,6 +9,7 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.training_data.structures import StoryGraph
 
 
 class CommandProcessorComponent(GraphComponent):
@@ -31,9 +32,12 @@ class CommandProcessorComponent(GraphComponent):
         return cls(execution_context)
 
     def execute_commands(
-        self, tracker: DialogueStateTracker, flows: FlowsList
+        self,
+        tracker: DialogueStateTracker,
+        flows: FlowsList,
+        story_graph: StoryGraph,
     ) -> List[Event]:
         """Execute commands to update tracker state."""
         return rasa.dialogue_understanding.processor.command_processor.execute_commands(
-            tracker, flows, self._execution_context
+            tracker, flows, self._execution_context, story_graph
         )

rasa/e2e_test/aggregate_test_stats_calculator.py

@@ -0,0 +1,134 @@
+from dataclasses import dataclass
+from typing import List, Optional, Set, TYPE_CHECKING
+
+import structlog
+
+from rasa.e2e_test.assertions import _get_all_assertion_subclasses
+
+if TYPE_CHECKING:
+    from rasa.e2e_test.assertions import Assertion
+    from rasa.e2e_test.e2e_test_case import TestCase
+    from rasa.e2e_test.e2e_test_result import TestResult
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class AccuracyCalculation:
+    """Data class for storing the accuracy calculation for an assertion type."""
+
+    assertion_type: str
+    accuracy: float
+
+
+class AggregateTestStatsCalculator:
+    """Class for calculating the aggregate test statistics for assertion types."""
+
+    def __init__(
+        self,
+        passed_results: List["TestResult"],
+        failed_results: List["TestResult"],
+        test_cases: List["TestCase"],
+    ) -> None:
+        self.passed_results = passed_results
+        self.failed_results = failed_results
+        self.test_cases = test_cases
+
+        self.failed_assertion_set: Set["Assertion"] = set()
+        self.failed_test_cases_without_assertion_failure: Set[str] = set()
+        self.passed_count_mapping = {
+            subclass_type: 0
+            for subclass_type in _get_all_assertion_subclasses().keys()
+            if subclass_type != ""
+        }
+        self.failed_count_mapping = {
+            subclass_type: 0
+            for subclass_type in _get_all_assertion_subclasses().keys()
+            if subclass_type != ""
+        }
+
+    def calculate(self) -> List[AccuracyCalculation]:
+        """Calculates the aggregate test statistics for assertion types."""
+        self._update_failed_count_mapping()
+        self._update_passed_count_mapping()
+
+        accuracy_calculations = []
+
+        for assertion_type in self.passed_count_mapping.keys():
+            accuracy = self._calculate_accuracy(assertion_type)
+            if accuracy is None:
+                continue
+
+            accuracy_calculations.append(AccuracyCalculation(assertion_type, accuracy))
+
+        return accuracy_calculations
+
+    def _calculate_accuracy(self, assertion_type: str) -> Optional[float]:
+        """Calculates the accuracy for the given assertion type."""
+        passed_count = self.passed_count_mapping[assertion_type]
+        failed_count = self.failed_count_mapping[assertion_type]
+
+        total_count = passed_count + failed_count
+
+        if total_count == 0:
+            structlogger.debug(
+                "aggregate_test_stats.calculate_accuracy."
+                "no_test_cases_for_assertion_type",
+                assertion_type=assertion_type,
+            )
+            return None
+
+        return passed_count / total_count
+
+    def _update_passed_count_mapping(self) -> None:
+        """Updates the passed count mapping based on the passed results.
+
+        We only count the assertions of passed tests and those
+        that are not in the failed assertion set.
+        We also do not count the assertions that follow a failed assertion.
+        """
+        passed_test_case_names = [
+            passed.test_case.name for passed in self.passed_results
+        ]
+        # We filter out test cases that failed without an assertion failure
+        filtered_test_cases = [
+            test_case
+            for test_case in self.test_cases
+            if test_case.name not in self.failed_test_cases_without_assertion_failure
+        ]
+
+        for test_case in filtered_test_cases:
+            if test_case.name in passed_test_case_names:
+                for step in test_case.steps:
+                    if step.assertions is None:
+                        continue
+
+                    for assertion in step.assertions:
+                        self.passed_count_mapping[assertion.type()] += 1
+            else:
+                for step in test_case.steps:
+                    if step.assertions is None:
+                        continue
+
+                    for assertion in step.assertions:
+                        if assertion not in self.failed_assertion_set:
+                            self.passed_count_mapping[assertion.type()] += 1
+                        else:
+                            break
+
+    def _update_failed_count_mapping(self) -> None:
+        """Updates the failed count mapping based on the failed results."""
+        for failed in self.failed_results:
+            if failed.assertion_failure is None:
+                structlogger.debug(
+                    "aggregate_test_stats.calculate."
+                    "no_assertion_failure_in_failed_result",
+                    test_case=failed.test_case.name,
+                )
+                self.failed_test_cases_without_assertion_failure.add(
+                    failed.test_case.name
+                )
+                continue
+
+            self.failed_assertion_set.add(failed.assertion_failure.assertion)
+            self.failed_count_mapping[failed.assertion_failure.assertion.type()] += 1