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

rasa/shared/core/flows/flow.py

@@ -1,33 +1,40 @@
 from __future__ import annotations
 
+import copy
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Text, Optional, Dict, Any, List, Set
-from pypred import Predicate
+from pathlib import Path
+from typing import Text, Optional, Dict, Any, List, Set, Union
+
 import structlog
+from pypred import Predicate
 
 import rasa.shared.utils.io
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.flows.flow_path import PathNode, FlowPath, FlowPathsList
 from rasa.shared.core.flows.flow_step import FlowStep
-
-from rasa.shared.core.flows.flow_step_links import StaticFlowStepLink
-from rasa.shared.core.flows.nlu_trigger import NLUTriggers
-from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
-from rasa.shared.core.flows.steps.constants import (
-    CONTINUE_STEP_PREFIX,
-    START_STEP,
-    END_STEP,
+from rasa.shared.core.flows.flow_step_links import (
+    FlowStepLink,
+    StaticFlowStepLink,
+    IfFlowStepLink,
+    ElseFlowStepLink,
 )
+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 (
     CollectInformationFlowStep,
     EndFlowStep,
     StartFlowStep,
     ActionFlowStep,
 )
-from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+from rasa.shared.core.flows.steps.constants import (
+    CONTINUE_STEP_PREFIX,
+    START_STEP,
+    END_STEP,
+)
+from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 from rasa.shared.core.slots import Slot
 
-
 structlogger = structlog.get_logger()
 
 
@@ -51,14 +58,21 @@ class Flow:
     """
     A flag that checks whether the flow should always be included in the prompt or not.
     """
+    file_path: Optional[str] = None
+    """The path to the file where the flow is stored."""
 
     @staticmethod
-    def from_json(flow_id: Text, data: Dict[Text, Any]) -> Flow:
+    def from_json(
+        flow_id: Text,
+        data: Dict[Text, Any],
+        file_path: Optional[Union[str, Path]] = None,
+    ) -> Flow:
         """Create a Flow object from serialized data.
 
         Args:
             flow_id: id of the flow
             data: data for a Flow object in a serialized format.
+            file_path: the file path of the flow
 
         Returns:
             A Flow object.
@@ -66,6 +80,9 @@ class Flow:
         step_sequence = FlowStepSequence.from_json(data.get("steps"))
         nlu_triggers = NLUTriggers.from_json(data.get("nlu_trigger"))
 
+        if file_path and isinstance(file_path, Path):
+            file_path = str(file_path)
+
         return Flow(
             id=flow_id,
             custom_name=data.get("name"),
@@ -75,8 +92,16 @@ class Flow:
             guard_condition=str(data["if"]) if "if" in data else None,
             step_sequence=Flow.resolve_default_ids(step_sequence),
             nlu_triggers=nlu_triggers,
+            # If we are reading the flows in after training the file_path is part of
+            # data. When the model is trained, take the provided file_path.
+            file_path=data.get("file_path") if "file_path" in data else file_path,
         )
 
+    def get_full_name(self) -> str:
+        if self.file_path:
+            return f"{self.file_path}::{self.name}"
+        return self.name
+
     @staticmethod
     def create_default_name(flow_id: str) -> str:
         """Create a default flow name for when it is missing."""
@@ -140,6 +165,8 @@ class Flow:
             data["always_include_in_prompt"] = self.always_include_in_prompt
         if self.nlu_triggers:
             data["nlu_trigger"] = self.nlu_triggers.as_json()
+        if self.file_path:
+            data["file_path"] = self.file_path
 
         return data
 
@@ -360,3 +387,171 @@ class Flow:
                 return True
 
         return False
+
+    def extract_all_paths(self) -> FlowPathsList:
+        """Extracts all possible flow paths.
+
+        Extracts all possible flow paths from a given flow structure by
+        recursively exploring each step.
+        This function initializes an empty list to collect paths, an empty path list,
+        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
+        current_path: FlowPath = FlowPath(flow=self.id, nodes=[])
+        step_ids_visited: 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))
+
+        structlogger.debug(
+            "shared.core.flows.flow.extract_all_paths",
+            comment="Extraction complete",
+            number_of_paths=len(flow_paths_list.paths),
+            flow_name=self.name,
+        )
+        return flow_paths_list
+
+    def _go_over_steps(
+        self,
+        steps_to_go: Union[str, List[FlowStep]],
+        current_path: FlowPath,
+        completed_paths: FlowPathsList,
+        step_ids_visited: 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_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.
+
+        Returns:
+            None: This function modifies collected_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"],
+                    )
+                )
+
+                # 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,
+                    )
+
+    def _handle_links(
+        self,
+        links: List[FlowStepLink],
+        path: FlowPath,
+        collected_paths: FlowPathsList,
+        step_ids_visited: set,
+    ) -> None:
+        """Processes the next step in a flow.
+
+        Potentially recursively calling itself to handle conditional paths and
+        branching.
+
+        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.
+
+        Returns:
+            None: Modifies collected_paths in place by appending new paths
+            as they are completed.
+        """
+        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
+
+                self._go_over_steps(
+                    target_steps,
+                    copy.deepcopy(path),
+                    collected_paths,
+                    copy.deepcopy(step_ids_visited),
+                )

rasa/shared/core/flows/flow_path.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Set
+
+import structlog
+
+NODE_KEY_SEPARATOR = " | "
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class PathNode:
+    """Representation of a path step."""
+
+    step_id: str
+    """Step ID"""
+
+    flow: str
+    """Flow name"""
+
+    lines: Optional[str] = None
+    """Line numbers range from the original flow .yaml file"""
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PathNode):
+            return False
+
+        return self.flow == other.flow and self.step_id == other.step_id
+
+    def __hash__(self) -> int:
+        return hash((self.flow, self.step_id))
+
+
+@dataclass
+class FlowPath:
+    """Representation of a path through a flow.
+
+    Attributes:
+        flow (str): The name of the flow.
+        nodes (List[PathNode]): A list of nodes that constitute the path.
+        test_name (str): Name of the test from which it was extracted.
+        test_passing (bool): Test status: True if 'passed'.
+    """
+
+    flow: str
+    nodes: List[PathNode] = field(default_factory=list)
+
+    def are_paths_matching(self, other_path: "FlowPath") -> bool:
+        """Compares this FlowPath to another to determine if they are identical."""
+        if len(self.nodes) != len(other_path.nodes):
+            return False
+        return all(
+            node == other_node for node, other_node in zip(self.nodes, other_path.nodes)
+        )
+
+
+@dataclass
+class FlowPathsList:
+    """Representing a list of all available paths through a flow.
+
+    Attributes:
+        flow (str): The name of the flow.
+        paths (List[FlowPath]): All paths of that flow.
+    """
+
+    flow: str
+    paths: List[FlowPath] = field(default=list)
+
+    def get_unique_nodes(self) -> Set[PathNode]:
+        """Returns the unique nodes of all flow paths."""
+        nodes = set()
+
+        for path in self.paths:
+            for node in path.nodes:
+                nodes.add(node)
+
+        return nodes
+
+    def get_number_of_unique_nodes(self) -> int:
+        return len(self.get_unique_nodes())
+
+    def is_path_part_of_list(self, flow_path: FlowPath) -> bool:
+        """Checks if the FlowPath exists in a list of FlowPaths."""
+        return any(flow_path.are_paths_matching(path) for path in self.paths)

rasa/shared/core/flows/flows_list.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import List, Generator, Any, Optional, Dict, Text, Set
+from pathlib import Path
+from typing import List, Generator, Any, Optional, Dict, Text, Set, Union
 
 import rasa.shared.utils.io
 from rasa.shared.core.flows import Flow
+from rasa.shared.core.flows.flow_path import FlowPathsList
 from rasa.shared.core.flows.validation import (
     validate_flow,
     validate_link_in_call_restriction,
@@ -64,11 +67,16 @@ class FlowsList:
         return FlowsList(list(merged_flows.values()))
 
     @classmethod
-    def from_json(cls, data: Optional[Dict[Text, Dict[Text, Any]]]) -> FlowsList:
-        """Create a FlowsList object from serialized data
+    def from_json(
+        cls,
+        data: Optional[Dict[Text, Dict[Text, Any]]],
+        file_path: Optional[Union[str, Path]] = None,
+    ) -> FlowsList:
+        """Create a FlowsList object from serialized data.
 
         Args:
             data: data for a FlowsList in a serialized format
+            file_path: the file path of the flows
 
         Returns:
             A FlowsList object.
@@ -78,7 +86,7 @@ class FlowsList:
 
         return cls(
             underlying_flows=[
-                Flow.from_json(flow_id, flow_config)
+                Flow.from_json(flow_id, flow_config, file_path)
                 for flow_id, flow_config in data.items()
             ]
         )
@@ -139,7 +147,8 @@ class FlowsList:
         """Get all ids of flows that can be started by a user.
 
         Returns:
-            The ids of all flows that can be started by a user."""
+        The ids of all flows that can be started by a user.
+        """
         return {f.id for f in self.user_flows}
 
     @property
@@ -147,7 +156,8 @@ class FlowsList:
         """Get all ids of flows.
 
         Returns:
-            The ids of all flows."""
+        The ids of all flows.
+        """
         return {f.id for f in self.underlying_flows}
 
     @property
@@ -155,7 +165,8 @@ class FlowsList:
         """Get all flows that can be started by a user.
 
         Returns:
-            All flows that can be started by a user."""
+        All flows that can be started by a user.
+        """
         return FlowsList(
             [f for f in self.underlying_flows if not f.is_rasa_default_flow]
         )
@@ -179,14 +190,14 @@ class FlowsList:
             slots: The slots to evaluate the starting conditions against.
 
         Returns:
-            All flows for which the starting conditions are met."""
+        All flows for which the starting conditions are met.
+        """
         return FlowsList(
             [f for f in self.underlying_flows if f.is_startable(context, slots)]
         )
 
     def get_flows_always_included_in_prompt(self) -> FlowsList:
-        """
-        Gets all flows based on their inclusion status in prompts.
+        """Gets all flows based on their inclusion status in prompts.
 
         Args:
             always_included: Inclusion status.
@@ -221,3 +232,10 @@ class FlowsList:
     def available_custom_actions(self) -> Set[str]:
         """Get all custom actions collected by flows."""
         return set().union(*[flow.custom_actions for flow in self.underlying_flows])
+
+    def extract_flow_paths(self) -> Dict[str, FlowPathsList]:
+        paths = {}
+        for flow in self.user_flows.underlying_flows:
+            paths[flow.id] = flow.extract_all_paths()
+
+        return paths