rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/shared/core/flows/flow_step.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Dict,
+    Generator,
+    Optional,
+    Set,
+    Text,
+)
+import structlog
+
+from rasa.shared.exceptions import RasaException
+
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow_step_links import FlowStepLinks
+
+structlogger = structlog.get_logger()
+
+
+def step_from_json(data: Dict[Text, Any]) -> FlowStep:
+    """Create a specific FlowStep from serialized data.
+
+    Args:
+        data: data for a specific FlowStep object in a serialized data format.
+
+    Returns:
+        An instance of a specific FlowStep class.
+    """
+    from rasa.shared.core.flows.steps import (
+        ActionFlowStep,
+        CollectInformationFlowStep,
+        LinkFlowStep,
+        SetSlotsFlowStep,
+        NoOperationFlowStep,
+        CallFlowStep,
+    )
+
+    if "action" in data:
+        return ActionFlowStep.from_json(data)
+    if "collect" in data:
+        return CollectInformationFlowStep.from_json(data)
+    if "link" in data:
+        return LinkFlowStep.from_json(data)
+    if "call" in data:
+        return CallFlowStep.from_json(data)
+    if "set_slots" in data:
+        return SetSlotsFlowStep.from_json(data)
+    if "noop" in data:
+        return NoOperationFlowStep.from_json(data)
+    raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
+
+
+@dataclass
+class FlowStep:
+    """A single step in a flow."""
+
+    custom_id: Optional[Text]
+    """The id of the flow step."""
+    idx: int
+    """The index of the step in the flow."""
+    description: Optional[Text]
+    """The description of the flow step."""
+    metadata: Dict[Text, Any]
+    """Additional, unstructured information about this flow step."""
+    next: FlowStepLinks
+    """The next steps of the flow step."""
+
+    @classmethod
+    def from_json(cls, data: Dict[Text, Any]) -> FlowStep:
+        """Create a FlowStep object from data in a serialized format.
+
+        Args:
+            data: The data for a FlowStep object in a serialized format.
+
+        Returns:
+            The FlowStep object.
+        """
+        from rasa.shared.core.flows.flow_step_links import FlowStepLinks
+        from rasa.shared.core.flows.steps.constants import UNSET_FLOW_STEP_ID
+
+        return FlowStep(
+            # the idx is set once the flow, which contains this step, is created
+            idx=UNSET_FLOW_STEP_ID,
+            custom_id=data.get("id"),
+            description=data.get("description"),
+            metadata=data.get("metadata", {}),
+            next=FlowStepLinks.from_json(data.get("next", [])),
+        )
+
+    def does_allow_for_next_step(self) -> bool:
+        """Most steps allow linking to the next step. But some don't."""
+        return True
+
+    def as_json(self) -> Dict[Text, Any]:
+        """Serialize the FlowStep object.
+
+        Returns:
+            The FlowStep as serialized data.
+        """
+        data: Dict[Text, Any] = {"id": self.id}
+
+        if dumped_next := self.next.as_json():
+            data["next"] = dumped_next
+        if self.description:
+            data["description"] = self.description
+        if self.metadata:
+            data["metadata"] = self.metadata
+        return data
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Recursively generates the steps in the tree."""
+        yield self
+        yield from self.next.steps_in_tree(should_resolve_calls)
+
+    @property
+    def id(self) -> Text:
+        """Returns the id of the flow step."""
+        return self.custom_id or self.default_id
+
+    @property
+    def default_id(self) -> str:
+        """Returns the default id of the flow step."""
+        return f"{self.idx}_{self.default_id_postfix}"
+
+    @property
+    def default_id_postfix(self) -> str:
+        """Returns the default id postfix of the flow step."""
+        return "step"
+
+    @property
+    def utterances(self) -> Set[str]:
+        """Return all the utterances used in this step."""
+        return set()
+
+
+@dataclass
+class FlowStepWithFlowReference:
+    step: FlowStep
+    """The step."""
+    flow_id: str
+    """The id of the flow that contains the step."""

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=[])