rasa-pro 3.9.18__py3-none-any.whl

rasa/shared/core/flows/flows_yaml_schema.json

@@ -0,0 +1,217 @@
+{
+  "type": "object",
+  "required": ["flows"],
+  "properties": {
+    "version": {
+      "type": "string"
+    },
+    "flows": {
+      "type": "object",
+      "schema_name": "dictionary of flows",
+      "patternProperties": {
+        "^[A-Za-z_][A-Za-z0-9_]*$": {
+          "$ref": "#/$defs/flow"
+        }
+      }
+    }
+  },
+  "$defs": {
+    "nlu_trigger": {
+      "type": "array",
+      "schema_name": "list of nlu triggers",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "oneOf": [
+          {
+            "schema_name": "intent trigger",
+            "type": "object",
+            "required": ["intent"],
+            "additionalProperties": false,
+            "properties": {
+              "intent": {
+                "type": "object",
+                "properties": {
+                  "confidence_threshold": {
+                    "type": "number"
+                  },
+                  "name": {
+                    "type": "string"
+                  }
+                },
+                "required": ["name"]
+              }
+            }
+          },
+          {
+            "schema_name": "simple intent trigger",
+            "properties": {
+              "intent": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      }
+    },
+    "steps": {
+      "type": "array",
+      "schema_name": "list of steps",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "next": {
+            "anyOf": [
+              {
+                "schema_name": "list of conditions",
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "oneOf": [
+                    {
+                      "schema_name": "if-then block",
+                      "required": ["if", "then"]
+                    },
+                    {
+                      "schema_name": "else block",
+                      "required": ["else"]
+                    }
+                  ],
+                  "properties": {
+                    "else": {
+                      "oneOf": [
+                        {
+                          "type": "string",
+                          "schema_name": "step id"
+                        },
+                        {
+                          "$ref": "#/$defs/steps",
+                          "schema_name": "list of steps"
+                        }
+                      ]
+                    },
+                    "if": {
+                      "type": ["boolean", "string"]
+                    },
+                    "then": {
+                      "oneOf": [
+                        {
+                          "$ref": "#/$defs/steps",
+                          "schema_name": "list of steps"
+                        },
+                        {
+                          "type": "string",
+                          "schema_name": "step id"
+                        }
+                      ]
+                    }
+                  }
+                }
+              },
+              {
+                "type": "string",
+                "schema_name": "step id"
+              }
+            ]
+          },
+          "action": { "type": "string" },
+          "collect": { "type": "string" },
+          "link": { "type": "string" },
+          "call": { "type": "string" },
+          "set_slots": { "$ref": "#/$defs/set_slots", "schema_name": "slot set" }
+        },
+        "oneOf": [
+          { "required": ["action"], "schema_name": "action step" },
+          { "required": ["collect"], "schema_name": "collect step" },
+          { "required": ["link"], "schema_name": "link step" },
+          { "required": ["call"], "schema_name": "call step" },
+          { "required": ["set_slots"], "schema_name": "slot set step" },
+          { "required": ["noop"], "schema_name": "" }
+        ],
+        "dependentSchemas": {
+          "action": {
+            "additionalProperties": false,
+            "properties": {
+              "id": {},
+              "next": {},
+              "action": {}
+            }
+          },
+          "noop": {
+            "required": ["next"]
+          },
+          "collect": {
+            "additionalProperties": false,
+            "properties": {
+              "collect": {},
+              "id": {},
+              "next": {},
+              "description": {
+                "type": "string"
+              },
+              "ask_before_filling": {
+                "type": "boolean"
+              },
+              "reset_after_flow_ends": {
+                "type": "boolean"
+              },
+              "utter": {
+                "type": "string"
+              },
+              "rejections": {
+                "type": "array",
+                "schema_name": "list of rejections",
+                "items": {
+                  "type": "object",
+                  "required": ["if", "utter"],
+                  "properties": {
+                    "if": {
+                      "type": ["boolean", "string"]
+                    },
+                    "utter": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "flow": {
+      "required": ["steps", "description"],
+      "type": "object",
+      "additionalProperties": false,
+      "schema_name": "dictionary with flow properties",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "if": {
+          "type": ["string", "boolean"]
+        },
+        "always_include_in_prompt": {
+          "type": "boolean"
+        },
+        "name": {
+          "type": "string"
+        },
+        "nlu_trigger": {
+          "$ref": "#/$defs/nlu_trigger"
+        },
+        "steps": {
+          "$ref": "#/$defs/steps"
+        }
+      }
+    },
+    "set_slots": {
+      "type": "array",
+      "schema_name": "list of slot sets",
+      "items": {
+        "type": "object"
+      }
+    }
+  }
+}

rasa/shared/core/flows/nlu_trigger.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+
+from rasa.shared.exceptions import YamlException
+from rasa.shared.nlu.constants import INTENT, INTENT_NAME_KEY, PREDICTED_CONFIDENCE_KEY
+from rasa.shared.nlu.training_data.message import Message
+
+
+@dataclass
+class NLUTrigger:
+    """Condition for triggering of a flow through intents with confidence thresholds."""
+
+    intent: str
+    """The intent to trigger the flow."""
+    confidence_threshold: float
+    """The minimum threshold of confidence for the intent."""
+
+    def is_triggered(self, intent: str, confidence: float) -> bool:
+        """Check if condition is triggered by the given intent and confidence.
+
+        Args:
+            intent: The intent to check.
+            confidence: The confidence to check.
+
+        Returns:
+            Whether the trigger condition is triggered
+            by the given intent and confidence.
+        """
+        return self.intent == intent and confidence >= self.confidence_threshold
+
+
+@dataclass
+class NLUTriggers:
+    """List of nlu triggers, e.g. conditions to start a flow through intents."""
+
+    trigger_conditions: List[NLUTrigger]
+    """The trigger conditions of the flow."""
+
+    @classmethod
+    def from_json(cls, data: List[Dict[str, Any]]) -> Optional["NLUTriggers"]:
+        """Create an NLUTriggers object from serialized data.
+
+        Args:
+            data: data for an NLUTriggers object in a serialized format.
+
+        Returns:
+            An NLUTriggers object.
+
+        Raises:
+            YamlException: If data format is not as expected.
+        """
+        if not data:
+            return None
+
+        trigger_conditions = []
+
+        for nlu_trigger_config in data:
+            if not isinstance(nlu_trigger_config, Dict):
+                raise YamlException("NLUTrigger definition not valid. Expected 'dict'.")
+            for value in nlu_trigger_config.values():
+                if isinstance(value, str):
+                    # syntax '- intent: some_intent' was used
+                    trigger_conditions.append(NLUTrigger(value, 0.0))
+                elif isinstance(value, Dict):
+                    # syntax
+                    # '- intent:
+                    #      name: some_intent'
+                    # was used
+
+                    # if no confidence threshold is set, use 0.0 as default
+                    confidence = value.get("confidence_threshold", 0.0)
+
+                    trigger_conditions.append(
+                        NLUTrigger(value["name"], float(confidence))
+                    )
+
+        return NLUTriggers(trigger_conditions=trigger_conditions)
+
+    def as_json(self) -> List[Dict[str, Any]]:
+        """Returns the nlu trigger conditions as a list.
+
+        Returns:
+            The nlu trigger conditions as a list.
+        """
+        dump = []
+
+        for trigger_condition in self.trigger_conditions:
+            dump.append(
+                {
+                    "intent": {
+                        "name": trigger_condition.intent,
+                        "confidence_threshold": trigger_condition.confidence_threshold,
+                    }
+                }
+            )
+
+        return dump
+
+    def is_triggered(self, message: Message) -> bool:
+        """Returns whether the flow is triggered by the given intent and threshold.
+
+        Args:
+            message: The user message to check.
+
+        Returns:
+            Whether the flow step is triggered by the given intent and threshold.
+        """
+        if not message.get(INTENT) or not message.get(INTENT)[INTENT_NAME_KEY]:
+            return False
+
+        intent: str = message.get(INTENT)[INTENT_NAME_KEY]
+        confidence: float = message.get(INTENT)[PREDICTED_CONFIDENCE_KEY]
+
+        return any(
+            trigger_condition.is_triggered(intent, confidence)
+            for trigger_condition in self.trigger_conditions
+        )

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

@@ -0,0 +1,24 @@
+from .no_operation import NoOperationFlowStep
+from .action import ActionFlowStep
+from .collect import CollectInformationFlowStep
+from .continuation import ContinueFlowStep
+from .end import EndFlowStep
+from .internal import InternalFlowStep
+from .link import LinkFlowStep
+from .set_slots import SetSlotsFlowStep
+from .start import StartFlowStep
+from .call import CallFlowStep
+
+# to make ruff happy and use the imported names
+all_steps = [
+    ActionFlowStep,
+    CollectInformationFlowStep,
+    ContinueFlowStep,
+    EndFlowStep,
+    InternalFlowStep,
+    LinkFlowStep,
+    SetSlotsFlowStep,
+    StartFlowStep,
+    NoOperationFlowStep,
+    CallFlowStep,
+]

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

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Text, Dict, Any, Set
+
+from rasa.shared.constants import UTTER_PREFIX
+from rasa.shared.core.flows.flow_step import FlowStep
+
+
+@dataclass
+class ActionFlowStep(FlowStep):
+    """A flow step that that defines an action to be executed."""
+
+    action: Text
+    """The action of the flow step."""
+
+    @classmethod
+    def from_json(cls, data: Dict[Text, Any]) -> ActionFlowStep:
+        """Create an ActionFlowStep object from serialized data
+
+        Args:
+            data: data for an ActionFlowStep object in a serialized format
+
+        Returns:
+            An ActionFlowStep object
+        """
+        base = super().from_json(data)
+        return ActionFlowStep(
+            action=data["action"],
+            **base.__dict__,
+        )
+
+    def as_json(self) -> Dict[Text, Any]:
+        """Serialize the ActionFlowStep
+
+        Returns:
+            The ActionFlowStep object as serialized data.
+        """
+        data = super().as_json()
+        data["action"] = self.action
+        return data
+
+    @property
+    def default_id_postfix(self) -> str:
+        """Returns the default id postfix of the flow step."""
+        return self.action
+
+    @property
+    def utterances(self) -> Set[str]:
+        """Return all the utterances used in this step."""
+        return {self.action} if self.action.startswith(UTTER_PREFIX) else set()
+
+    @property
+    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

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

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generator, Optional, Text, Dict, Any
+
+from rasa.shared.core.flows.flow_step import FlowStep
+
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow import Flow
+
+
+@dataclass
+class CallFlowStep(FlowStep):
+    """Represents the configuration of an call flow step."""
+
+    call: Text
+    """The flow to be called."""
+    called_flow_reference: Optional["Flow"] = None
+
+    @classmethod
+    def from_json(cls, data: Dict[Text, Any]) -> CallFlowStep:
+        """Used to read flow steps from parsed YAML.
+
+        Args:
+            data: The parsed YAML as a dictionary.
+
+        Returns:
+            The parsed flow step.
+        """
+        base = super().from_json(data)
+        return CallFlowStep(
+            call=data.get("call", ""),
+            **base.__dict__,
+        )
+
+    def as_json(self) -> Dict[Text, Any]:
+        """Returns the flow step as a dictionary.
+
+        Returns:
+            The flow step as a dictionary.
+        """
+        dump = super().as_json()
+        dump["call"] = self.call
+        return dump
+
+    def steps_in_tree(
+        self, should_resolve_calls: bool = True
+    ) -> Generator[FlowStep, None, None]:
+        """Returns the steps in the tree of the flow step."""
+
+        yield self
+
+        if should_resolve_calls:
+            if not self.called_flow_reference:
+                raise ValueError("Call flow reference not set.")
+
+            yield from self.called_flow_reference.steps_with_calls_resolved
+
+        yield from self.next.steps_in_tree(should_resolve_calls)
+
+    @property
+    def default_id_postfix(self) -> str:
+        """Returns the default id postfix of the flow step."""
+        return f"call_{self.call}"

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

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Any, List, Set
+
+from rasa.shared.constants import UTTER_ASK_PREFIX, ACTION_ASK_PREFIX
+from rasa.shared.core.flows.flow_step import FlowStep
+
+
+@dataclass
+class SlotRejection:
+    """A pair of validation condition and an utterance for the case of failure."""
+
+    if_: str
+    """The condition that should be checked."""
+    utter: str
+    """The utterance that should be executed if the condition is met."""
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SlotRejection:
+        """Create a SlotRejection object from serialized data.
+
+        Args:
+            data: data for a SlotRejection object in a serialized format
+
+        Returns:
+            A SlotRejection object
+        """
+        return SlotRejection(
+            if_=data["if"],
+            utter=data["utter"],
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Serialize the SlotRejection object.
+
+        Returns:
+            the SlotRejection object as serialized data
+        """
+        return {
+            "if": self.if_,
+            "utter": self.utter,
+        }
+
+
+@dataclass
+class CollectInformationFlowStep(FlowStep):
+    """A flow step for asking the user for information to fill a specific slot."""
+
+    collect: str
+    """The collect information of the flow step."""
+    utter: str
+    """The utterance that the assistant uses to ask for the slot."""
+    collect_action: str
+    """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
+    """Whether to always ask the question even if the slot is already filled."""
+    reset_after_flow_ends: bool = True
+    """Whether to reset the slot value at the end of the flow."""
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> CollectInformationFlowStep:
+        """Create a CollectInformationFlowStep object from serialized data.
+
+        Args:
+            data: data for a CollectInformationFlowStep object in a serialized format
+
+        Returns:
+            A CollectInformationFlowStep object
+        """
+        base = super().from_json(data)
+        return CollectInformationFlowStep(
+            collect=data["collect"],
+            utter=data.get("utter", f"{UTTER_ASK_PREFIX}{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']}",
+            ask_before_filling=data.get("ask_before_filling", False),
+            reset_after_flow_ends=data.get("reset_after_flow_ends", True),
+            rejections=[
+                SlotRejection.from_dict(rejection)
+                for rejection in data.get("rejections", [])
+            ],
+            **base.__dict__,
+        )
+
+    def as_json(self) -> Dict[str, Any]:
+        """Serialize the CollectInformationFlowStep object.
+
+        Returns:
+            the CollectInformationFlowStep object as serialized data
+        """
+        data = super().as_json()
+        data["collect"] = self.collect
+        data["utter"] = self.utter
+        data["ask_before_filling"] = self.ask_before_filling
+        data["reset_after_flow_ends"] = self.reset_after_flow_ends
+        data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
+
+        return data
+
+    @property
+    def default_id_postfix(self) -> str:
+        """Returns the default id postfix of the flow step."""
+        return f"collect_{self.collect}"
+
+    @property
+    def utterances(self) -> Set[str]:
+        """Return all the utterances used in this step."""
+        return {self.utter} | {r.utter for r in self.rejections}

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

@@ -0,0 +1,5 @@
+CONTINUE_STEP_PREFIX = "NEXT:"
+START_STEP = "START"
+END_STEP = "END"
+DEFAULT_STEPS = {END_STEP, START_STEP}
+UNSET_FLOW_STEP_ID = -1

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

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rasa.shared.core.flows.flow_step_links import FlowStepLinks, StaticFlowStepLink
+from rasa.shared.core.flows.steps.constants import (
+    CONTINUE_STEP_PREFIX,
+    UNSET_FLOW_STEP_ID,
+)
+from rasa.shared.core.flows.steps.internal import InternalFlowStep
+
+
+@dataclass
+class ContinueFlowStep(InternalFlowStep):
+    """A flow step that is dynamically introduced to jump to other flow steps."""
+
+    def __init__(self, target_step_id: str) -> None:
+        """Initializes a continue-step flow step."""
+        super().__init__(
+            idx=UNSET_FLOW_STEP_ID,
+            custom_id=CONTINUE_STEP_PREFIX + target_step_id,
+            description=None,
+            metadata={},
+            # The continue step links to the step that should be continued.
+            # The flow policy in a sense only "runs" the logic of a step
+            # when it transitions to that step, once it is there it will use
+            # the next link to transition to the next step. This means that
+            # if we want to "re-run" a step, we need to link to it again.
+            # This is why the continue step links to the step that should be
+            # continued.
+            next=FlowStepLinks(links=[StaticFlowStepLink(target_step_id)]),
+        )
+
+    @staticmethod
+    def continue_step_for_id(step_id: str) -> str:
+        return CONTINUE_STEP_PREFIX + step_id

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

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rasa.shared.core.flows.flow_step_links import FlowStepLinks
+from rasa.shared.core.flows.steps.constants import END_STEP, UNSET_FLOW_STEP_ID
+from rasa.shared.core.flows.steps.internal import InternalFlowStep
+
+
+@dataclass
+class EndFlowStep(InternalFlowStep):
+    """A dynamically added flow step that marks the end of a flow."""
+
+    def __init__(self) -> None:
+        """Initializes an end flow step."""
+        super().__init__(
+            idx=UNSET_FLOW_STEP_ID,
+            custom_id=END_STEP,
+            description=None,
+            metadata={},
+            next=FlowStepLinks(links=[]),
+        )