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

rasa/shared/core/flows/flows_list.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+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,
+    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,
+    DuplicatedFlowIdException,
+)
+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, ignore_duplicates: bool = True
+    ) -> 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.
+            ignore_duplicates: Whether to ignore duplicate flow ids, or raise an error.
+
+        Returns:
+            Merged flow list.
+        """
+        merged_flows: Dict[Text, Flow] = dict()
+        for flow_list in other:
+            for flow in flow_list:
+                if flow.id in merged_flows:
+                    if ignore_duplicates:
+                        continue
+                    current_flow_path = flow.file_path
+                    other_flow_path = merged_flows[flow.id].file_path
+                    raise DuplicatedFlowIdException(
+                        flow.id, current_flow_path, other_flow_path
+                    )
+                merged_flows[flow.id] = flow
+        return FlowsList(list(merged_flows.values()))
+
+    @classmethod
+    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.
+        """
+        if not data:
+            return cls(underlying_flows=[])
+
+        return cls(
+            underlying_flows=[
+                Flow.from_json(flow_id, flow_config, file_path)
+                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, ignore_duplicates: bool = True) -> FlowsList:
+        """Merges two lists of flows together."""
+        return FlowsList.from_multiple_flows_lists(
+            self, other, ignore_duplicates=ignore_duplicates
+        )
+
+    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, ask_before_filling: Optional[bool] = None
+    ) -> 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()
+            if ask_before_filling is None
+            or step.ask_before_filling == ask_before_filling
+        }
+
+    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

rasa/shared/core/flows/flows_yaml_schema.json

@@ -0,0 +1,303 @@
+{
+    "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": {},
+                            "metadata": {}
+                        }
+                    },
+                    "noop": {
+                        "required": [
+                            "next"
+                        ]
+                    },
+                    "collect": {
+                        "additionalProperties": false,
+                        "properties": {
+                            "collect": {},
+                            "id": {},
+                            "next": {},
+                            "metadata": {},
+                            "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"
+                },
+                "file_path": {
+                    "type": "string"
+                },
+                "steps": {
+                    "$ref": "#/$defs/steps"
+                },
+                "persisted_slots": {
+                    "$ref": "#/$defs/persisted_slots"
+                }
+            }
+        },
+        "set_slots": {
+            "type": "array",
+            "schema_name": "list of slot sets",
+            "items": {
+                "type": "object"
+            }
+        },
+        "persisted_slots": {
+            "type": "array",
+            "schema_name": "list of slots",
+            "items": {
+                "type": "string"
+            }
+        }
+    }
+}

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
+        )