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

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Text
+import rasa.dialogue_understanding.processor.command_processor
+
+from rasa.engine.graph import ExecutionContext, GraphComponent
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.training_data.structures import StoryGraph
+
+
+class CommandProcessorComponent(GraphComponent):
+    """Processes commands by issuing events to modify a tracker.
+
+    Minimal component that applies commands to a tracker."""
+
+    def __init__(self, execution_context: ExecutionContext):
+        self._execution_context = execution_context
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> CommandProcessorComponent:
+        """Creates component (see parent class for full docstring)."""
+        return cls(execution_context)
+
+    def execute_commands(
+        self,
+        tracker: DialogueStateTracker,
+        flows: FlowsList,
+        story_graph: StoryGraph,
+    ) -> List[Event]:
+        """Execute commands to update tracker state."""
+        return rasa.dialogue_understanding.processor.command_processor.execute_commands(
+            tracker, flows, self._execution_context, story_graph
+        )

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+import copy
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+import structlog
+import typing
+import jsonpatch
+
+if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class DialogueStack:
+    """Represents the current dialogue stack."""
+
+    frames: List["DialogueStackFrame"]
+
+    @staticmethod
+    def from_dict(data: List[Dict[str, Any]]) -> DialogueStack:
+        """Creates a `DialogueStack` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStack` from.
+
+        Returns:
+            The created `DialogueStack`.
+        """
+        from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+
+        return DialogueStack(
+            frames=[DialogueStackFrame.create_typed_frame(frame) for frame in data]
+        )
+
+    @staticmethod
+    def empty() -> DialogueStack:
+        """Creates an empty `DialogueStack`.
+
+        Returns:
+            The created empty `DialogueStack`.
+        """
+        return DialogueStack(frames=[])
+
+    def as_dict(self) -> List[Dict[str, Any]]:
+        """Returns the `DialogueStack` as a dictionary.
+
+        Returns:
+            The `DialogueStack` as a dictionary.
+        """
+        return [frame.as_dict() for frame in self.frames]
+
+    def copy(self) -> DialogueStack:
+        return copy.deepcopy(self)
+
+    def push(self, frame: "DialogueStackFrame", index: Optional[int] = None) -> None:
+        """Pushes a new frame onto the stack.
+
+        If the frame shouldn't be put on top of the stack, the index can be
+        specified. Not specifying an index equals `push(frame, index=len(frames))`.
+
+        Args:
+            frame: The frame to push onto the stack.
+            index: The index to insert the frame at. If `None`, the frame
+                is put on top of the stack.
+        """
+        if index is None:
+            self.frames.append(frame)
+        else:
+            self.frames.insert(index, frame)
+
+    def update(self, frame: "DialogueStackFrame") -> None:
+        """Updates the topmost frame.
+
+        Args:
+            frame: The frame to update.
+        """
+        if not self.is_empty():
+            self.pop()
+
+        self.push(frame)
+
+    def pop(self) -> "DialogueStackFrame":
+        """Pops the topmost frame from the stack.
+
+        Returns:
+            The popped frame.
+        """
+        return self.frames.pop()
+
+    def current_context(self) -> Dict[str, Any]:
+        """Returns the context of the topmost frame.
+
+        Returns:
+            The context of the topmost frame.
+        """
+        if self.is_empty():
+            return {}
+
+        return self.frames[-1].context_as_dict(self.frames[:-1])
+
+    def top(
+        self,
+        ignore: Optional[Callable[["DialogueStackFrame"], bool]] = None,
+    ) -> Optional["DialogueStackFrame"]:
+        """Returns the topmost frame from the stack.
+
+        Args:
+            ignore_frame: The ID of the flow to ignore. Picks the top most
+                frame that has a different flow ID.
+
+        Returns:
+            The topmost frame.
+        """
+        for frame in reversed(self.frames):
+            if ignore and ignore(frame):
+                continue
+            return frame
+        return None
+
+    def is_empty(self) -> bool:
+        """Checks if the stack is empty.
+
+        Returns:
+            `True` if the stack is empty, `False` otherwise.
+        """
+        return len(self.frames) == 0
+
+    def update_from_patch(self, patch_dump: str) -> DialogueStack:
+        """Updates the stack from a patch.
+
+        Args:
+            patch_dump: The patch to apply to the stack.
+
+        Returns:
+            The updated stack."""
+        patch = jsonpatch.JsonPatch.from_string(patch_dump)
+        dialogue_stack_dump = patch.apply(self.as_dict())
+        return DialogueStack.from_dict(dialogue_stack_dump)
+
+    def create_stack_patch(self, updated_stack: DialogueStack) -> Optional[str]:
+        """Creates a patch to update the stack to the updated stack state.
+
+        Example:
+            > stack = DialogueStack.from_dict([
+            >     {
+            >         "type": "flow",
+            >         "frame_type": "regular",
+            >         "flow_id": "foo",
+            >         "step_id": "START",
+            >         "frame_id": "test",
+            >     }
+            > ])
+            > updated_stack = DialogueStack.from_dict([
+            >     {
+            >         "type": "flow",
+            >         "frame_type": "regular",
+            >         "flow_id": "foo",
+            >         "step_id": "1",
+            >         "frame_id": "test",
+            >     }
+            > ])
+            > stack.create_stack_patch(updated_stack)
+            '[{"op": "replace", "path": "/0/step_id", "value": "1"}]'
+
+        Args:
+            updated_stack: The updated stack.
+
+        Returns:
+            The patch to update the stack to the updated stack state.
+        """
+        patch = jsonpatch.JsonPatch.from_diff(self.as_dict(), updated_stack.as_dict())
+
+        if patch:
+            return patch.to_string()
+        return None

rasa/dialogue_understanding/stack/frames/__init__.py

@@ -0,0 +1,19 @@
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    UserFlowStackFrame,
+    BaseFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.search_frame import SearchStackFrame
+from rasa.dialogue_understanding.stack.frames.chit_chat_frame import ChitChatStackFrame
+
+__all__ = [
+    "DialogueStackFrame",
+    "BaseFlowStackFrame",
+    "PatternFlowStackFrame",
+    "UserFlowStackFrame",
+    "SearchStackFrame",
+    "ChitChatStackFrame",
+]

rasa/dialogue_understanding/stack/frames/chit_chat_frame.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+
+
+@dataclass
+class ChitChatStackFrame(DialogueStackFrame):
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "chitchat"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ChitChatStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return ChitChatStackFrame(
+            frame_id=data["frame_id"],
+        )

rasa/dialogue_understanding/stack/frames/dialogue_stack_frame.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass, field
+import dataclasses
+from enum import Enum
+from functools import lru_cache
+from typing import Any, Dict, List, Tuple, Type
+
+import structlog
+from rasa.shared.exceptions import RasaException
+
+import rasa.shared.utils.common
+from rasa.shared.utils.io import random_string
+
+
+structlogger = structlog.get_logger()
+
+
+def generate_stack_frame_id() -> str:
+    """Generates a stack frame ID.
+
+    Returns:
+        The generated stack frame ID.
+    """
+    return random_string(8)
+
+
+@lru_cache
+def _get_all_subclasses() -> List[Type[DialogueStackFrame]]:
+    stack_frame_subclasses = rasa.shared.utils.common.all_subclasses(DialogueStackFrame)
+
+    # Get all the subclasses of DialogueStackFrame from the patterns package
+    # in case these are not all imported at runtime
+    modules = rasa.shared.utils.common.import_package_modules(
+        "rasa.dialogue_understanding.patterns"
+    )
+    extra_subclasses = [
+        clazz
+        for module in modules
+        for _, clazz in inspect.getmembers(module, inspect.isclass)
+        if issubclass(clazz, DialogueStackFrame) and clazz not in stack_frame_subclasses
+    ]
+
+    stack_frame_subclasses.extend(extra_subclasses)
+    return stack_frame_subclasses
+
+
+class InvalidStackFrameType(RasaException):
+    """Raised if a stack frame type is invalid."""
+
+    def __init__(self, frame_type: str) -> None:
+        """Creates a `InvalidStackFrameType`.
+
+        Args:
+            frame_type: The invalid frame type.
+        """
+        super().__init__(f"Invalid stack frame type '{frame_type}'.")
+
+
+@dataclass
+class DialogueStackFrame:
+    """Represents the current flow step."""
+
+    frame_id: str = field(default_factory=generate_stack_frame_id)
+    """The ID of the current frame."""
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns the `DialogueStackFrame` as a dictionary.
+
+        Returns:
+            The `DialogueStackFrame` as a dictionary.
+        """
+
+        def custom_asdict_factory(fields: List[Tuple[str, Any]]) -> Dict[str, Any]:
+            """Converts enum values to their value."""
+
+            def rename_internal(field_name: str) -> str:
+                return field_name[:-1] if field_name.endswith("_") else field_name
+
+            return {
+                rename_internal(field): value.value
+                if isinstance(value, Enum)
+                else value
+                for field, value in fields
+            }
+
+        data = dataclasses.asdict(self, dict_factory=custom_asdict_factory)
+        data["type"] = self.type()
+        return data
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        raise NotImplementedError
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> DialogueStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        raise NotImplementedError
+
+    def context_as_dict(
+        self, underlying_frames: List[DialogueStackFrame]
+    ) -> Dict[str, Any]:
+        """Returns the context of the frame."""
+        return self.as_dict()
+
+    @staticmethod
+    def create_typed_frame(data: Dict[str, Any]) -> DialogueStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        typ = data.get("type")
+
+        for clazz in _get_all_subclasses():
+            try:
+                if typ == clazz.type():
+                    return clazz.from_dict(data)
+            except NotImplementedError:
+                # we don't want to raise an error if the frame type is not
+                # implemented, as this is ok to be raised by an abstract class
+                pass
+        else:
+            structlogger.warning("dialogue_stack.frame.unknown_type", data=data)
+            raise InvalidStackFrameType(typ)

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+from rasa.shared.core.flows.steps.constants import START_STEP
+from rasa.shared.core.flows import Flow, FlowsList, FlowStep
+from rasa.shared.exceptions import RasaException
+
+
+class InvalidFlowStackFrameType(RasaException):
+    """Raised if the stack frame type is invalid."""
+
+    def __init__(self, frame_type: Optional[str]) -> None:
+        """Creates a `InvalidFlowStackFrameType`.
+
+        Args:
+            frame_type: The invalid stack frame type.
+        """
+        super().__init__(f"Invalid stack frame type '{frame_type}'.")
+
+
+class FlowStackFrameType(str, Enum):
+    INTERRUPT = "interrupt"
+    """The frame is an interrupt frame.
+
+    This means that the previous flow was interrupted by this flow. An
+    interrupt should be used for frames that span multiple turns and
+    where we expect the user needing help to get back to the previous
+    flow."""
+    LINK = "link"
+    """The frame is a link frame.
+
+    This means that the previous flow linked to this flow."""
+
+    CALL = "call"
+    """The frame is a flow that is called from another flow."""
+
+    REGULAR = "regular"
+    """The frame is a regular frame.
+
+    In all other cases, this is the case."""
+
+    @staticmethod
+    def from_str(typ: Optional[str]) -> "FlowStackFrameType":
+        """Creates a `FlowStackFrameType` from a string.
+
+        Args:
+            typ: The string to create the `FlowStackFrameType` from.
+
+        Returns:
+            The created `FlowStackFrameType`."""
+        if typ is None:
+            return FlowStackFrameType.REGULAR
+        elif typ == FlowStackFrameType.INTERRUPT.value:
+            return FlowStackFrameType.INTERRUPT
+        elif typ == FlowStackFrameType.CALL.value:
+            return FlowStackFrameType.CALL
+        elif typ == FlowStackFrameType.LINK.value:
+            return FlowStackFrameType.LINK
+        elif typ == FlowStackFrameType.REGULAR.value:
+            return FlowStackFrameType.REGULAR
+        else:
+            raise InvalidFlowStackFrameType(typ)
+
+
+class InvalidFlowIdException(Exception):
+    """Raised if the flow ID is invalid."""
+
+    def __init__(self, flow_id: str) -> None:
+        """Creates a `InvalidFlowIdException`.
+
+        Args:
+            flow_id: The invalid flow ID.
+        """
+        super().__init__(f"Invalid flow ID '{flow_id}'.")
+
+
+class InvalidFlowStepIdException(Exception):
+    """Raised if the flow step ID is invalid."""
+
+    def __init__(self, flow_id: str, step_id: str) -> None:
+        """Creates a `InvalidFlowStepIdException`.
+
+        Args:
+            flow_id: The invalid flow ID.
+            step_id: The invalid flow step ID.
+        """
+        super().__init__(f"Invalid flow step ID '{step_id}' for flow '{flow_id}'.")
+
+
+@dataclass
+class BaseFlowStackFrame(DialogueStackFrame):
+    flow_id: str = ""  # needed to avoid "default arg before non-default" error
+    """The ID of the current flow."""
+    step_id: str = START_STEP
+    """The ID of the current step."""
+
+    def flow(self, all_flows: FlowsList) -> Flow:
+        """Returns the current flow.
+
+        Args:
+            all_flows: All flows in the assistant.
+
+        Returns:
+            The current flow."""
+        flow = all_flows.flow_by_id(self.flow_id)
+        if not flow:
+            # we shouldn't ever end up with a frame that belongs to a non
+            # existing flow, but if we do, we should raise an error
+            raise InvalidFlowIdException(self.flow_id)
+        return flow
+
+    def step(self, all_flows: FlowsList) -> FlowStep:
+        """Returns the current flow step.
+
+        Args:
+            all_flows: All flows in the assistant.
+
+        Returns:
+            The current flow step."""
+        flow = self.flow(all_flows)
+        step = flow.step_by_id(self.step_id)
+        if not step:
+            # we shouldn't ever end up with a frame that belongs to a non
+            # existing step, but if we do, we should raise an error
+            raise InvalidFlowStepIdException(self.flow_id, self.step_id)
+        return step
+
+
+@dataclass
+class UserFlowStackFrame(BaseFlowStackFrame):
+    frame_type: FlowStackFrameType = FlowStackFrameType.REGULAR
+    """The type of the frame. Defaults to `StackFrameType.REGULAR`."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "flow"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> UserFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return UserFlowStackFrame(
+            frame_id=data["frame_id"],
+            flow_id=data["flow_id"],
+            step_id=data["step_id"],
+            frame_type=FlowStackFrameType.from_str(data.get("frame_type")),
+        )

rasa/dialogue_understanding/stack/frames/pattern_frame.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from rasa.dialogue_understanding.stack.frames import BaseFlowStackFrame
+
+
+@dataclass
+class PatternFlowStackFrame(BaseFlowStackFrame):
+    """A stack frame that represents a pattern flow."""
+
+    pass

rasa/dialogue_understanding/stack/frames/search_frame.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+
+
+@dataclass
+class SearchStackFrame(DialogueStackFrame):
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "search"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SearchStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SearchStackFrame(
+            frame_id=data["frame_id"],
+        )