rasa-pro 3.13.0.dev3__py3-none-any.whl → 3.13.0.dev7__py3-none-any.whl

rasa/shared/core/flows/flow.py

@@ -38,6 +38,7 @@ from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
 from rasa.shared.core.flows.nlu_trigger import NLUTriggers
 from rasa.shared.core.flows.steps import (
     ActionFlowStep,
+    CallFlowStep,
     CollectInformationFlowStep,
     EndFlowStep,
     StartFlowStep,
@@ -52,6 +53,8 @@ from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
 
+DEFAULT_RUN_PATTERN_COMPLETED = True
+
 
 class FlowLanguageTranslation(BaseModel):
     """Represents the translation of the flow properties in a specific language."""
@@ -60,8 +63,15 @@ class FlowLanguageTranslation(BaseModel):
     """The human-readable name of the flow."""
 
     class Config:
+        """Config for the FlowLanguageTranslation class."""
+
         extra = "ignore"
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, FlowLanguageTranslation):
+            return self.name == other.name
+        return False
+
 
 @dataclass
 class Flow:
@@ -89,8 +99,25 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
-    run_pattern_completed: bool = True
+    run_pattern_completed: bool = DEFAULT_RUN_PATTERN_COMPLETED
     """Whether the pattern_completed flow should be run after the flow ends."""
+    metadata: Dict[Text, Any] = field(default_factory=dict)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Flow):
+            return (
+                self.id == other.id
+                and self.custom_name == other.custom_name
+                and self.description == other.description
+                and self.translation == other.translation
+                and self.guard_condition == other.guard_condition
+                and self.step_sequence == other.step_sequence
+                and self.nlu_triggers == other.nlu_triggers
+                and self.always_include_in_prompt == other.always_include_in_prompt
+                and self.persisted_slots == other.persisted_slots
+                and self.run_pattern_completed == other.run_pattern_completed
+            )
+        return False
 
     @staticmethod
     def from_json(
@@ -129,7 +156,9 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
             persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
-            run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
+            run_pattern_completed=data.get(
+                KEY_RUN_PATTERN_COMPLETED, DEFAULT_RUN_PATTERN_COMPLETED
+            ),
             translation=extract_translations(
                 translation_data=data.get(KEY_TRANSLATION, {})
             ),
@@ -208,7 +237,7 @@ class Flow:
         if self.persisted_slots:
             data[KEY_PERSISTED_SLOTS] = self.persisted_slots
         if self.run_pattern_completed is not None:
-            data["run_pattern_completed"] = self.run_pattern_completed
+            data[KEY_RUN_PATTERN_COMPLETED] = self.run_pattern_completed
         if self.translation:
             data[KEY_TRANSLATION] = {
                 language_code: translation.dict()
@@ -231,9 +260,9 @@ class Flow:
         return translation.name if translation else None
 
     def readable_name(self, language: Optional[Language] = None) -> str:
-        """
-        Returns the flow's name in the specified language if available; otherwise
-        falls back to the flow's name, and finally the flow's ID.
+        """Returns the flow's name in the specified language if available.
+
+        Otherwise falls back to the flow's name, and finally the flow's ID.
 
         Args:
             language: Preferred language code.
@@ -466,161 +495,156 @@ class Flow:
         and a set of visited step IDs to prevent revisiting steps.
         It calls `go_over_steps` to recursively explore and fill the paths list.
         """
-        flow_paths_list = FlowPathsList(self.id, paths=[])
-        steps: List[FlowStep] = self.steps
+        all_paths = FlowPathsList(self.id, paths=[])
+        start_step: FlowStep = self.first_step_in_flow()
         current_path: FlowPath = FlowPath(flow=self.id, nodes=[])
-        step_ids_visited: Set[str] = set()
+        visited_step_ids: Set[str] = set()
 
-        self._go_over_steps(steps, current_path, flow_paths_list, step_ids_visited)
-
-        if not flow_paths_list.is_path_part_of_list(current_path):
-            flow_paths_list.paths.append(copy.deepcopy(current_path))
+        self._go_over_steps(start_step, current_path, all_paths, visited_step_ids)
 
         structlogger.debug(
             "shared.core.flows.flow.extract_all_paths",
             comment="Extraction complete",
-            number_of_paths=len(flow_paths_list.paths),
+            number_of_paths=len(all_paths.paths),
             flow_name=self.name,
         )
-        return flow_paths_list
+        return all_paths
 
     def _go_over_steps(
         self,
-        steps_to_go: Union[str, List[FlowStep]],
+        current_step: FlowStep,
         current_path: FlowPath,
-        completed_paths: FlowPathsList,
-        step_ids_visited: Set[str],
+        all_paths: FlowPathsList,
+        visited_step_ids: Set[str],
     ) -> None:
         """Processes the flow steps recursively.
 
-        Either following direct step IDs or handling conditions, and adds complete
-        paths to the collected_paths.
-
         Args:
-            steps_to_go: Either a direct step ID or a list of steps to process.
+            current_step: The current step being processed.
             current_path: The current path being constructed.
-            completed_paths: The list where completed paths are added.
-            step_ids_visited: A set of step IDs that have been visited to avoid cycles.
+            all_paths: The list where completed paths are added.
+            visited_step_ids: A set of steps that have been visited to avoid cycles.
 
         Returns:
-            None: This function modifies collected_paths in place by appending new paths
+            None: This function modifies all_paths in place by appending new paths
             as they are found.
         """
-        # Case 1: If the steps_to_go is a custom_id string
-        # This happens when a "next" of, for example, a IfFlowStepLink is targeting
-        # a specific step by id
-        if isinstance(steps_to_go, str):
-            for i, step in enumerate(self.steps):
-                # We don't need to check for 'id' as a link can only happen to a
-                # custom id.
-                if step.custom_id == steps_to_go:
-                    self._go_over_steps(
-                        self.steps[i:], current_path, completed_paths, step_ids_visited
-                    )
-
-        # Case 2: If steps_to_go is a list of steps
-        else:
-            for i, step in enumerate(steps_to_go):
-                # 1. Check if the step is relevant for testable_paths extraction.
-                # We only create new path nodes for ActionFlowStep and
-                # CollectInformationFlowStep because these are externally visible
-                # changes in the assistant's behaviour (trackable in the e2e tests).
-                # For other flow steps, we only follow their links.
-                # We decided to ignore calls to other flows in our coverage analysis.
-                if not isinstance(step, (CollectInformationFlowStep, ActionFlowStep)):
-                    self._handle_links(
-                        step.next.links,
-                        current_path,
-                        completed_paths,
-                        step_ids_visited,
-                    )
-                    continue
-
-                # 2. Check if already visited this custom step id
-                # in order to keep track of loops
-                if step.custom_id is not None and step.custom_id in step_ids_visited:
-                    if not completed_paths.is_path_part_of_list(current_path):
-                        completed_paths.paths.append(copy.deepcopy(current_path))
-                    return  # Stop traversing this path if we've revisited a step
-                elif step.custom_id is not None:
-                    step_ids_visited.add(step.custom_id)
-
-                # 3. Append step info to the path
-                current_path.nodes.append(
-                    PathNode(
-                        flow=current_path.flow,
-                        step_id=step.id,
-                        lines=step.metadata["line_numbers"],
-                    )
+        # Check if the step is relevant for testable_paths extraction.
+        # We only create new path nodes for ActionFlowStep, CallFlowStep and
+        # CollectInformationFlowStep because these are externally visible
+        # changes in the assistant's behaviour (trackable in the e2e tests).
+        # For other flow steps, we only follow their links.
+        # We decided to ignore calls to other flows in our coverage analysis.
+        should_add_node = isinstance(
+            current_step, (CollectInformationFlowStep, ActionFlowStep, CallFlowStep)
+        )
+        if should_add_node:
+            # Add current step to the current path that is being constructed.
+            current_path.nodes.append(
+                PathNode(
+                    flow=current_path.flow,
+                    step_id=current_step.id,
+                    lines=current_step.metadata["line_numbers"],
                 )
+            )
 
-                # 4. Check if 'END' branch
-                if (
-                    len(step.next.links) == 1
-                    and isinstance(step.next.links[0], StaticFlowStepLink)
-                    and step.next.links[0].target == END_STEP
-                ):
-                    if not completed_paths.is_path_part_of_list(current_path):
-                        completed_paths.paths.append(copy.deepcopy(current_path))
-                    return
-                else:
-                    self._handle_links(
-                        step.next.links,
-                        current_path,
-                        completed_paths,
-                        step_ids_visited,
-                    )
+        if current_step.id in visited_step_ids or self.is_end_of_path(current_step):
+            # Found a cycle, or reached an end step, do not proceed further.
+            all_paths.paths.append(copy.deepcopy(current_path))
+            # Remove the last node from the path if it was added.
+            if should_add_node:
+                current_path.nodes.pop()
+            return
+
+        # Mark current step as visited in this path.
+        visited_step_ids.add(current_step.id)
+
+        # Iterate over all links of the current step.
+        for link in current_step.next.links:
+            self._handle_link(
+                current_path,
+                all_paths,
+                visited_step_ids,
+                link,
+            )
+
+        # Backtrack the current step and remove it from the path.
+        visited_step_ids.remove(current_step.id)
 
-    def _handle_links(
+        # Remove the last node from the path if it was added.
+        if should_add_node:
+            current_path.nodes.pop()
+
+    def _handle_link(
         self,
-        links: List[FlowStepLink],
-        path: FlowPath,
-        collected_paths: FlowPathsList,
-        step_ids_visited: set,
+        current_path: FlowPath,
+        all_paths: FlowPathsList,
+        visited_step_ids: Set[str],
+        link: FlowStepLink,
     ) -> None:
-        """Processes the next step in a flow.
-
-        Potentially recursively calling itself to handle conditional paths and
-        branching.
+        """Handles the next step in a flow.
 
         Args:
-            links: Links listed in the "next" attribute.
-            path: The current path taken in the flow.
-            collected_paths: A list of paths collected so far.
-            step_ids_visited: A set of step IDs that have already been visited
-                to avoid loops.
+            current_path: The current path being constructed.
+            all_paths: The list where completed paths are added.
+            visited_step_ids: A set of steps that have been visited to avoid cycles.
+            link: The link to be followed.
 
         Returns:
-            None: Modifies collected_paths in place by appending new paths
-            as they are completed.
+            None: This function modifies all_paths in place by appending new paths
+            as they are found.
         """
-        steps = self.steps
-
-        for link in links:
-            # Direct step id reference
-            if isinstance(link, StaticFlowStepLink):
-                # Find this id in the flow steps and restart from there
-                for i, step in enumerate(steps):
-                    if step.id == link.target_step_id:
-                        self._go_over_steps(
-                            steps[i:],
-                            copy.deepcopy(path),
-                            collected_paths,
-                            copy.deepcopy(step_ids_visited),
-                        )
-
-            # If conditions
-            elif isinstance(link, (IfFlowStepLink, ElseFlowStepLink)):
-                # Handling conditional paths
-                target_steps: Union[str, List[FlowStep]]
-                if isinstance(link.target_reference, FlowStepSequence):
-                    target_steps = link.target_reference.child_steps
-                else:
-                    target_steps = link.target_reference
-
+        # StaticFlowStepLink is a direct link to the next step.
+        if isinstance(link, StaticFlowStepLink):
+            # Find the step by its id and continue the path.
+            if step := self._get_step_by_step_id(link.target_step_id):
                 self._go_over_steps(
-                    target_steps,
-                    copy.deepcopy(path),
-                    collected_paths,
-                    copy.deepcopy(step_ids_visited),
+                    step,
+                    current_path,
+                    all_paths,
+                    visited_step_ids,
                 )
+                return
+        # IfFlowStepLink and ElseFlowStepLink are conditional links.
+        elif isinstance(link, (IfFlowStepLink, ElseFlowStepLink)):
+            if isinstance(link.target_reference, FlowStepSequence):
+                # If the target is a FlowStepSequence, we need to go over all
+                # child steps of the sequence.
+                for child_step in link.target_reference.child_steps:
+                    self._go_over_steps(
+                        child_step,
+                        current_path,
+                        all_paths,
+                        visited_step_ids,
+                    )
+                return
+            else:
+                # Find the step by its id and continue the path.
+                if step := self._get_step_by_step_id(link.target_reference):
+                    self._go_over_steps(
+                        step,
+                        current_path,
+                        all_paths,
+                        visited_step_ids,
+                    )
+                    return
+
+    def is_end_of_path(self, step: FlowStep) -> bool:
+        """Check if there is no path available from the current step."""
+        if (
+            len(step.next.links) == 1
+            and isinstance(step.next.links[0], StaticFlowStepLink)
+            and step.next.links[0].target == END_STEP
+        ):
+            return True
+        return False
+
+    def _get_step_by_step_id(
+        self,
+        step_id: Optional[str],
+    ) -> Optional[FlowStep]:
+        """Get a step by its id from a list of steps."""
+        for step in self.steps:
+            if step.id == step_id:
+                return step
+        return None

rasa/shared/core/flows/flow_step.py

@@ -100,7 +100,9 @@ class FlowStep:
         """Most steps allow linking to the next step. But some don't."""
         return True
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[Text, Any]:
         """Serialize the FlowStep object.
 
         Returns:
@@ -108,10 +110,13 @@ class FlowStep:
         """
         data: Dict[Text, Any] = {"id": self.id}
 
-        if dumped_next := self.next.as_json():
-            data["next"] = dumped_next
+        if step_properties:
+            data.update(step_properties)
+
         if self.description:
             data["description"] = self.description
+        if dumped_next := self.next.as_json():
+            data["next"] = dumped_next
         if self.metadata:
             data["metadata"] = self.metadata
         return data
@@ -143,6 +148,17 @@ class FlowStep:
         """Return all the utterances used in this step."""
         return set()
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FlowStep):
+            return False
+
+        return (
+            self.idx == other.idx
+            and self.description == other.description
+            and self.next == other.next
+            and self.flow_id == other.flow_id
+        )
+
 
 @dataclass
 class FlowStepWithFlowReference:

rasa/shared/core/flows/flow_step_links.py

@@ -74,6 +74,11 @@ class FlowStepLinks:
             depth = max(depth, link.depth_in_tree())
         return depth
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, FlowStepLinks):
+            return self.links == other.links
+        return False
+
 
 class FlowStepLink:
     """A flow step link that links two steps in a single flow."""
@@ -193,6 +198,11 @@ class BranchingFlowStepLink(FlowStepLink):
             return depth + 1
         return 1
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, BranchingFlowStepLink):
+            return self.target_reference == other.target_reference
+        return False
+
 
 @dataclass
 class IfFlowStepLink(BranchingFlowStepLink):
@@ -324,3 +334,8 @@ class StaticFlowStepLink(FlowStepLink):
     def depth_in_tree(self) -> int:
         """Returns the depth in the tree."""
         return 0
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, StaticFlowStepLink):
+            return self.target_step_id == other.target_step_id
+        return False

rasa/shared/core/flows/flow_step_sequence.py

@@ -70,3 +70,9 @@ class FlowStepSequence:
     def empty(cls) -> FlowStepSequence:
         """Create an empty FlowStepSequence object."""
         return cls(child_steps=[])
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, FlowStepSequence)
+            and self.child_steps == other.child_steps
+        )

rasa/shared/core/flows/nlu_trigger.py

@@ -28,6 +28,14 @@ class NLUTrigger:
         """
         return self.intent == intent and confidence >= self.confidence_threshold
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, NLUTrigger):
+            return (
+                self.intent == other.intent
+                and self.confidence_threshold == other.confidence_threshold
+            )
+        return False
+
 
 @dataclass
 class NLUTriggers:
@@ -115,3 +123,8 @@ class NLUTriggers:
             trigger_condition.is_triggered(intent, confidence)
             for trigger_condition in self.trigger_conditions
         )
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, NLUTriggers):
+            return self.trigger_conditions == other.trigger_conditions
+        return False

rasa/shared/core/flows/steps/action.py

@@ -31,15 +31,13 @@ class ActionFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the ActionFlowStep
 
         Returns:
             The ActionFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["action"] = self.action
-        return data
+        return super().as_json(step_properties={"action": self.action})
 
     @property
     def default_id_postfix(self) -> str:
@@ -55,3 +53,8 @@ class ActionFlowStep(FlowStep):
     def custom_action(self) -> Optional[str]:
         """Return all the custom actions used in this step."""
         return self.action if not self.action.startswith(UTTER_PREFIX) else None
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.action == other.action and super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/call.py

@@ -34,15 +34,13 @@ class CallFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Returns the flow step as a dictionary.
 
         Returns:
             The flow step as a dictionary.
         """
-        dump = super().as_json()
-        dump["call"] = self.call
-        return dump
+        return super().as_json(step_properties={"call": self.call})
 
     def steps_in_tree(
         self, should_resolve_calls: bool = True
@@ -62,3 +60,12 @@ class CallFlowStep(FlowStep):
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return f"call_{self.call}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return (
+                self.call == other.call
+                and self.called_flow_reference == other.called_flow_reference
+                and super().__eq__(other)
+            )
+        return False

rasa/shared/core/flows/steps/collect.py

@@ -7,6 +7,10 @@ from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
 
+DEFAULT_ASK_BEFORE_FILLING = False
+DEFAULT_RESET_AFTER_FLOW_ENDS = True
+DEFAULT_FORCE_SLOT_FILLING = False
+
 
 @dataclass
 class CollectInformationFlowStep(FlowStep):
@@ -20,9 +24,9 @@ class CollectInformationFlowStep(FlowStep):
     """The action that the assistant uses to ask for the slot."""
     rejections: List[SlotRejection]
     """how the slot value is validated using predicate evaluation."""
-    ask_before_filling: bool = False
+    ask_before_filling: bool = DEFAULT_ASK_BEFORE_FILLING
     """Whether to always ask the question even if the slot is already filled."""
-    reset_after_flow_ends: bool = True
+    reset_after_flow_ends: bool = DEFAULT_RESET_AFTER_FLOW_ENDS
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
@@ -43,7 +47,7 @@ class CollectInformationFlowStep(FlowStep):
         base = super().from_json(flow_id, data)
         return CollectInformationFlowStep(
             collect=data["collect"],
-            utter=data.get("utter", f"{UTTER_ASK_PREFIX}{data['collect']}"),
+            utter=data.get("utter", cls._default_utter(data["collect"])),
             # as of now it is not possible to define a different name for the
             # action, always use the default name 'action_ask_<slot_name>'
             collect_action=f"{ACTION_ASK_PREFIX}{data['collect']}",
@@ -57,7 +61,11 @@ class CollectInformationFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[str, Any]:
+    @staticmethod
+    def _default_utter(collect: str) -> str:
+        return f"{UTTER_ASK_PREFIX}{collect}"
+
+    def as_json(self) -> Dict[str, Any]:  # type: ignore[override]
         """Serialize the CollectInformationFlowStep object.
 
         Returns:
@@ -70,8 +78,7 @@ class CollectInformationFlowStep(FlowStep):
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
-
-        return data
+        return super().as_json(step_properties=data)
 
     @property
     def default_id_postfix(self) -> str:
@@ -82,3 +89,17 @@ class CollectInformationFlowStep(FlowStep):
     def utterances(self) -> Set[str]:
         """Return all the utterances used in this step."""
         return {self.utter} | {r.utter for r in self.rejections}
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return (
+                self.collect == other.collect
+                and self.utter == other.utter
+                and self.collect_action == other.collect_action
+                and self.rejections == other.rejections
+                and self.ask_before_filling == other.ask_before_filling
+                and self.reset_after_flow_ends == other.reset_after_flow_ends
+                and self.force_slot_filling == other.force_slot_filling
+                and super().__eq__(other)
+            )
+        return False

rasa/shared/core/flows/steps/internal.py

@@ -28,7 +28,7 @@ class InternalFlowStep(FlowStep):
             "or de-serialized."
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the InternalFlowStep object
 
         Returns:
@@ -43,3 +43,8 @@ class InternalFlowStep(FlowStep):
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         raise ValueError("Internal flow steps do not need a default id")
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/link.py

@@ -37,17 +37,20 @@ class LinkFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the LinkFlowStep object
 
         Returns:
             the LinkFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["link"] = self.link
-        return data
+        return super().as_json(step_properties={"link": self.link})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return f"link_{self.link}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.link == other.link and super().__eq__(other)
+        return False