rasa-pro 3.9.18__py3-none-any.whl

rasa/shared/core/flows/flow_step_links.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from dataclasses import dataclass
+from typing import List, Union, Dict, Text, Any, Optional, Generator
+
+from rasa.shared.core.flows.flow_step import FlowStep
+
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+
+@dataclass
+class FlowStepLinks:
+    """A list of flow step links."""
+
+    links: List[FlowStepLink]
+
+    @staticmethod
+    def from_json(data: Union[str, List[Dict[Text, Any]]]) -> FlowStepLinks:
+        """Create a FlowStepLinks object from a serialized data format.
+
+        Args:
+            data: data for a FlowStepLinks object in a serialized format.
+
+        Returns:
+            A FlowStepLinks object.
+        """
+        if not data:
+            return FlowStepLinks(links=[])
+
+        if isinstance(data, str):
+            return FlowStepLinks(links=[StaticFlowStepLink.from_json(data)])
+
+        return FlowStepLinks(
+            links=[
+                BranchingFlowStepLink.from_json(link_config)
+                for link_config in data
+                if link_config
+            ]
+        )
+
+    def as_json(self) -> Optional[Union[str, List[Dict[str, Any]]]]:
+        """Serialize the FlowStepLinks object.
+
+        Returns:
+            The FlowStepLinks object as serialized data.
+        """
+        if not self.links:
+            return None
+
+        if len(self.links) == 1 and isinstance(self.links[0], StaticFlowStepLink):
+            return self.links[0].as_json()
+
+        return [link.as_json() for link in self.links]
+
+    def no_link_available(self) -> bool:
+        """Returns whether no link is available."""
+        return len(self.links) == 0
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Returns the steps in the tree of the flow step links."""
+        for link in self.links:
+            yield from link.steps_in_tree(should_resolve_calls)
+
+    def depth_in_tree(self) -> int:
+        """Returns the max depth in the tree of the flow step links."""
+        depth = 0
+        for link in self.links:
+            depth = max(depth, link.depth_in_tree())
+        return depth
+
+
+class FlowStepLink:
+    """A flow step link that links two steps in a single flow."""
+
+    @property
+    def target(self) -> Text:
+        """Returns the target flow step id.
+
+        Returns:
+            The target flow step id.
+        """
+        raise NotImplementedError()
+
+    def as_json(self) -> Any:
+        """Serialize the FlowStepLink object.
+
+        Returns:
+            The FlowStepLink as serialized data.
+        """
+        raise NotImplementedError()
+
+    @staticmethod
+    def from_json(data: Any) -> FlowStepLink:
+        """Create a FlowStepLink object from a serialized data format.
+
+        Args:
+            data: data for a FlowStepLink object in a serialized format.
+
+        Returns:
+            The FlowStepLink object.
+        """
+        raise NotImplementedError()
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Recursively generates the steps in the tree."""
+        raise NotImplementedError()
+
+    def child_steps(self) -> List[FlowStep]:
+        """Returns the steps of the linked FlowStepSequence if any."""
+        raise NotImplementedError()
+
+    def depth_in_tree(self) -> int:
+        """Returns the depth in the tree."""
+        raise NotImplementedError()
+
+
+@dataclass
+class BranchingFlowStepLink(FlowStepLink):
+    target_reference: Union[Text, FlowStepSequence]
+    """The id of the linked step or a sequence of steps."""
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Recursively generates the steps in the tree."""
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(self.target_reference, FlowStepSequence):
+            if should_resolve_calls:
+                yield from self.target_reference.steps_with_calls_resolved
+            else:
+                yield from self.target_reference.steps
+
+    def child_steps(self) -> List[FlowStep]:
+        """Returns the steps of the linked flow step sequence if any."""
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(self.target_reference, FlowStepSequence):
+            return self.target_reference.child_steps
+        else:
+            return []
+
+    @property
+    def target(self) -> Text:
+        """Return the target flow step id."""
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(self.target_reference, FlowStepSequence):
+            if first := self.target_reference.first():
+                return first.id
+            else:
+                raise RuntimeError(
+                    "Step sequence is empty despite previous validation of "
+                    "this not happening"
+                )
+        else:
+            return self.target_reference
+
+    @staticmethod
+    def from_json(data: Dict[Text, Any]) -> BranchingFlowStepLink:
+        """Create a BranchingFlowStepLink object from a serialized data format.
+
+        Args:
+            data: data for a BranchingFlowStepLink object in a serialized format.
+
+        Returns:
+            a BranchingFlowStepLink object.
+        """
+        if "if" in data:
+            return IfFlowStepLink.from_json(data)
+        else:
+            return ElseFlowStepLink.from_json(data)
+
+    def depth_in_tree(self) -> int:
+        """Returns the depth in the tree."""
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(self.target_reference, FlowStepSequence):
+            depth = 0
+            for step in self.target_reference.steps_with_calls_resolved:
+                if isinstance(step.next, FlowStepLinks):
+                    depth = max(depth, step.next.depth_in_tree())
+            return depth + 1
+        return 1
+
+
+@dataclass
+class IfFlowStepLink(BranchingFlowStepLink):
+    """A flow step link that links to another step or step sequence conditionally."""
+
+    condition: Text
+    """The condition that needs to be satisfied to follow this flow step link."""
+
+    @staticmethod
+    def from_json(data: Dict[Text, Any]) -> IfFlowStepLink:
+        """Create an IfFlowStepLink object from a serialized data format.
+
+        Args:
+            data: data for a IfFlowStepLink in a serialized format.
+
+        Returns:
+            An IfFlowStepLink object.
+        """
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(data["then"], str):
+            return IfFlowStepLink(target_reference=data["then"], condition=data["if"])
+        else:
+            return IfFlowStepLink(
+                target_reference=FlowStepSequence.from_json(data["then"]),
+                condition=data["if"],
+            )
+
+    def as_json(self) -> Dict[Text, Any]:
+        """Serialize the IfFlowStepLink object.
+
+        Returns:
+            the IfFlowStepLink object as serialized data.
+        """
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        return {
+            "if": self.condition,
+            "then": self.target_reference.as_json()
+            if isinstance(self.target_reference, FlowStepSequence)
+            else self.target_reference,
+        }
+
+
+@dataclass
+class ElseFlowStepLink(BranchingFlowStepLink):
+    """A flow step link that is taken when conditional flow step links weren't taken."""
+
+    @staticmethod
+    def from_json(data: Dict[Text, Any]) -> ElseFlowStepLink:
+        """Create an ElseFlowStepLink object from serialized data.
+
+        Args:
+            data: data for an ElseFlowStepLink in a serialized format
+
+        Returns:
+            An ElseFlowStepLink
+        """
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        if isinstance(data["else"], str):
+            return ElseFlowStepLink(target_reference=data["else"])
+        else:
+            return ElseFlowStepLink(
+                target_reference=FlowStepSequence.from_json(data["else"])
+            )
+
+    def as_json(self) -> Dict[Text, Any]:
+        """Serialize the ElseFlowStepLink object
+
+        Returns:
+            The ElseFlowStepLink as serialized data.
+        """
+        from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
+
+        return {
+            "else": self.target_reference.as_json()
+            if isinstance(self.target_reference, FlowStepSequence)
+            else self.target_reference
+        }
+
+
+@dataclass
+class StaticFlowStepLink(FlowStepLink):
+    """A static flow step link, linking to a step in the same flow unconditionally."""
+
+    target_step_id: Text
+    """The id of the linked step."""
+
+    @staticmethod
+    def from_json(data: Text) -> StaticFlowStepLink:
+        """Create a StaticFlowStepLink from serialized data
+
+        Args:
+            data: data for a StaticFlowStepLink in a serialized format
+
+        Returns:
+            A StaticFlowStepLink object
+        """
+        return StaticFlowStepLink(data)
+
+    def as_json(self) -> Text:
+        """Serialize the StaticFlowStepLink object
+
+        Returns:
+            The StaticFlowStepLink object as serialized data.
+        """
+        return self.target
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Recursively generates the steps in the tree."""
+        # static links do not have any child steps
+        yield from []
+
+    def child_steps(self) -> List[FlowStep]:
+        """Returns the steps of the linked FlowStepSequence if any."""
+        return []
+
+    @property
+    def target(self) -> Text:
+        """Returns the target step id."""
+        return self.target_step_id
+
+    def depth_in_tree(self) -> int:
+        """Returns the depth in the tree."""
+        return 0

rasa/shared/core/flows/flow_step_sequence.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Dict, Text, Any, Optional
+
+from rasa.shared.core.flows.flow_step import FlowStep, step_from_json
+from rasa.shared.core.flows.steps.internal import InternalFlowStep
+
+
+@dataclass
+class FlowStepSequence:
+    """A Sequence of flow steps."""
+
+    child_steps: List[FlowStep]
+
+    @staticmethod
+    def from_json(data: List[Dict[Text, Any]]) -> FlowStepSequence:
+        """Create a FlowStepSequence object from serialized data
+
+        Args:
+            data: data for a StepSequence in a serialized format
+
+        Returns:
+            A StepSequence object including its flow step objects.
+        """
+
+        flow_steps: List[FlowStep] = [step_from_json(config) for config in data]
+
+        return FlowStepSequence(child_steps=flow_steps)
+
+    def as_json(self) -> List[Dict[Text, Any]]:
+        """Serialize the StepSequence object and contained FlowStep objects
+
+        Returns:
+            the FlowStepSequence and its FlowSteps as serialized data
+        """
+        return [
+            step.as_json()
+            for step in self.child_steps
+            if not isinstance(step, InternalFlowStep)
+        ]
+
+    def _resolve_steps(self, should_resolve_calls: bool) -> List[FlowStep]:
+        """Resolves the steps of the flow."""
+        return [
+            step
+            for child_step in self.child_steps
+            for step in child_step.steps_in_tree(
+                should_resolve_calls=should_resolve_calls
+            )
+        ]
+
+    @property
+    def steps_with_calls_resolved(self) -> List[FlowStep]:
+        """Return all steps in this step sequence and their sub steps."""
+        return self._resolve_steps(should_resolve_calls=True)
+
+    @property
+    def steps(self) -> List[FlowStep]:
+        """Return the steps of the flow without steps of called flows"""
+        return self._resolve_steps(should_resolve_calls=False)
+
+    def first(self) -> Optional[FlowStep]:
+        """Return the first step of the sequence."""
+        return self.child_steps[0] if self.child_steps else None
+
+    @classmethod
+    def empty(cls) -> FlowStepSequence:
+        """Create an empty FlowStepSequence object."""
+        return cls(child_steps=[])

rasa/shared/core/flows/flows_list.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import List, Generator, Any, Optional, Dict, Text, Set
+
+import rasa.shared.utils.io
+from rasa.shared.core.flows import Flow
+from rasa.shared.core.flows.validation import (
+    validate_flow,
+    validate_link_in_call_restriction,
+    validate_called_flows_exists,
+    validate_linked_flows_exists,
+    validate_nlu_trigger,
+    validate_patterns_are_not_called_or_linked,
+    validate_patterns_are_not_calling_or_linking_other_flows,
+    validate_step_ids_are_unique,
+)
+from rasa.shared.core.slots import Slot
+
+
+@dataclass
+class FlowsList:
+    """A collection of flows.
+
+    This class defines a number of methods that are executed across the available flows,
+    such as fingerprinting (for retraining caching), collecting flows with
+    specific attributes or collecting all utterances across all flows.
+    """
+
+    underlying_flows: List[Flow]
+    """The flows contained in this FlowsList."""
+
+    def __post_init__(self) -> None:
+        """Initializes the FlowsList object."""
+        self._resolve_called_flows()
+
+    def __iter__(self) -> Generator[Flow, None, None]:
+        """Iterates over the flows."""
+        yield from self.underlying_flows
+
+    def __len__(self) -> int:
+        """Return the length of this FlowsList."""
+        return len(self.underlying_flows)
+
+    def is_empty(self) -> bool:
+        """Returns whether the flows list is empty."""
+        return len(self.underlying_flows) == 0
+
+    @classmethod
+    def from_multiple_flows_lists(cls, *other: FlowsList) -> FlowsList:
+        """Merges multiple lists of flows into a single flow ensuring each flow is
+        unique, based on its ID.
+
+        Args:
+            other: Variable number of flow lists instances to be merged.
+
+        Returns:
+            Merged flow list.
+        """
+        merged_flows = dict()
+        for flow_list in other:
+            for flow in flow_list:
+                if flow.id not in merged_flows:
+                    merged_flows[flow.id] = flow
+        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
+
+        Args:
+            data: data for a FlowsList in a serialized format
+
+        Returns:
+            A FlowsList object.
+        """
+        if not data:
+            return cls(underlying_flows=[])
+
+        return cls(
+            underlying_flows=[
+                Flow.from_json(flow_id, flow_config)
+                for flow_id, flow_config in data.items()
+            ]
+        )
+
+    def _resolve_called_flows(self) -> None:
+        """Resolves the called flows."""
+        from rasa.shared.core.flows.steps import CallFlowStep
+
+        for flow in self.underlying_flows:
+            for step in flow.steps:
+                if isinstance(step, CallFlowStep) and not step.called_flow_reference:
+                    # only resolve the reference, if it isn't already resolved
+                    step.called_flow_reference = self.flow_by_id(step.call)
+
+    def as_json_list(self) -> List[Dict[Text, Any]]:
+        """Serialize the FlowsList object to list format and not to the original dict.
+
+        Returns:
+            The FlowsList object as serialized data in a list
+        """
+        return [flow.as_json() for flow in self.underlying_flows]
+
+    def fingerprint(self) -> str:
+        """Creates a fingerprint of the existing flows.
+
+        Returns:
+            The fingerprint of the flows.
+        """
+        flow_dicts = [flow.as_json() for flow in self.underlying_flows]
+        return rasa.shared.utils.io.get_list_fingerprint(flow_dicts)
+
+    def merge(self, other: FlowsList) -> FlowsList:
+        """Merges two lists of flows together."""
+        return FlowsList.from_multiple_flows_lists(self, other)
+
+    def flow_by_id(self, flow_id: Text) -> Optional[Flow]:
+        """Return the flow with the given id."""
+        for flow in self.underlying_flows:
+            if flow.id == flow_id:
+                return flow
+        else:
+            return None
+
+    def validate(self) -> None:
+        """Validate the flows."""
+        for flow in self.underlying_flows:
+            validate_flow(flow)
+        validate_nlu_trigger(self.underlying_flows)
+        validate_link_in_call_restriction(self)
+        validate_called_flows_exists(self)
+        validate_linked_flows_exists(self)
+        validate_patterns_are_not_called_or_linked(self)
+        validate_patterns_are_not_calling_or_linking_other_flows(self)
+        validate_step_ids_are_unique(self)
+
+    @property
+    def user_flow_ids(self) -> Set[str]:
+        """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."""
+        return {f.id for f in self.user_flows}
+
+    @property
+    def flow_ids(self) -> Set[str]:
+        """Get all ids of flows.
+
+        Returns:
+            The ids of all flows."""
+        return {f.id for f in self.underlying_flows}
+
+    @property
+    def user_flows(self) -> FlowsList:
+        """Get all flows that can be started by a user.
+
+        Returns:
+            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]
+        )
+
+    @property
+    def utterances(self) -> Set[str]:
+        """Retrieve all utterances of all flows"""
+        return {
+            utterance for flow in self.underlying_flows for utterance in flow.utterances
+        }
+
+    def get_startable_flows(
+        self,
+        context: Optional[Dict[Text, Any]] = None,
+        slots: Optional[Dict[Text, Slot]] = None,
+    ) -> FlowsList:
+        """Get all flows for which the starting conditions are met.
+
+        Args:
+            context: The context data to evaluate the starting conditions against.
+            slots: The slots to evaluate the starting conditions against.
+
+        Returns:
+            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.
+
+        Args:
+            always_included: Inclusion status.
+
+        Returns:
+            All flows with the given inclusion status.
+        """
+        return FlowsList(
+            [f for f in self.underlying_flows if f.always_include_in_prompt]
+        )
+
+    def exclude_link_only_flows(self) -> FlowsList:
+        """Filter the given flows and exclude the flows that can
+        be started only via link (flow guard evaluates to `False`).
+
+        Returns:
+            List of flows that doesn't contain flows that are
+            only startable via link (another flow).
+        """
+        return FlowsList(
+            [f for f in self.underlying_flows if not f.is_startable_only_via_link()]
+        )
+
+    def available_slot_names(self) -> Set[str]:
+        """Get all slot names collected by flows."""
+        return {
+            step.collect
+            for flow in self.underlying_flows
+            for step in flow.get_collect_steps()
+        }
+
+    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])