rasa-pro 3.12.0.dev11__py3-none-any.whl → 3.12.0.dev12__py3-none-any.whl

rasa/core/channels/voice_stream/genesys.py

@@ -1,331 +0,0 @@
-import asyncio
-import json
-from typing import Any, Awaitable, Callable, Dict, Optional, Text
-
-import structlog
-from sanic import (  # type: ignore[attr-defined]
-    Blueprint,
-    HTTPResponse,
-    Request,
-    Websocket,
-    response,
-)
-
-from rasa.core.channels import UserMessage
-from rasa.core.channels.voice_ready.utils import CallParameters
-from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
-from rasa.core.channels.voice_stream.call_state import (
-    call_state,
-)
-from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
-from rasa.core.channels.voice_stream.voice_channel import (
-    ContinueConversationAction,
-    EndConversationAction,
-    NewAudioAction,
-    VoiceChannelAction,
-    VoiceInputChannel,
-    VoiceOutputChannel,
-)
-
-# Not mentioned in the documentation but observed in Geneys's example
-# https://github.com/GenesysCloudBlueprints/audioconnector-server-reference-implementation
-MAXIMUM_BINARY_MESSAGE_SIZE = 64000  # 64KB
-logger = structlog.get_logger(__name__)
-
-
-def map_call_params(data: Dict[Text, Any]) -> CallParameters:
-    """Map the twilio stream parameters to the CallParameters dataclass."""
-    parameters = data["parameters"]
-    participant = parameters["participant"]
-    # sent as {"ani": "tel:+491604697810"}
-    ani = participant.get("ani", "")
-    user_phone = ani.split(":")[-1] if ani else ""
-
-    return CallParameters(
-        call_id=parameters.get("conversationId", ""),
-        user_phone=user_phone,
-        bot_phone=participant.get("dnis", ""),
-    )
-
-
-class GenesysOutputChannel(VoiceOutputChannel):
-    @classmethod
-    def name(cls) -> str:
-        return "genesys"
-
-    async def send_audio_bytes(
-        self, recipient_id: str, audio_bytes: RasaAudioBytes
-    ) -> None:
-        """
-        Send audio bytes to the recipient with buffering.
-
-        Genesys throws a rate limit error with too many audio messages.
-        To avoid this, we buffer the audio messages and send them in chunks.
-
-        - global.inbound.binary.average.rate.per.second: 5
-        The allowed average rate per second of inbound binary data
-
-        - global.inbound.binary.max: 25
-        The maximum number of inbound binary data messages
-        that can be sent instantaneously
-
-        https://developer.genesys.cloud/organization/organization/limits#audiohook
-        """
-        call_state.audio_buffer.extend(audio_bytes)
-
-        # If we receive a non-standard chunk size, assume it's the end of a sequence
-        # or buffer is more than 32KB (this is half of genesys's max audio message size)
-        if len(audio_bytes) != 1024 or len(call_state.audio_buffer) >= (
-            MAXIMUM_BINARY_MESSAGE_SIZE / 2
-        ):
-            # TODO: we should send the buffer when we receive a synthesis complete event
-            # from TTS. This will ensure that the last audio chunk is always sent.
-            await self._send_audio_buffer(self.voice_websocket)
-
-    async def _send_audio_buffer(self, ws: Websocket) -> None:
-        """Send the audio buffer to the recipient if it's not empty."""
-        if call_state.audio_buffer:
-            buffer_bytes = bytes(call_state.audio_buffer)
-            await self._send_bytes_to_ws(ws, buffer_bytes)
-            call_state.audio_buffer.clear()
-
-    async def _send_bytes_to_ws(self, ws: Websocket, data: bytes) -> None:
-        """Send audio bytes to the recipient as a binary websocket message."""
-        if len(data) <= MAXIMUM_BINARY_MESSAGE_SIZE:
-            await self.voice_websocket.send(data)
-        else:
-            # split the audio into chunks
-            current_position = 0
-            while current_position < len(data):
-                end_position = min(
-                    current_position + MAXIMUM_BINARY_MESSAGE_SIZE, len(data)
-                )
-                await self.voice_websocket.send(data[current_position:end_position])
-                current_position = end_position
-
-    async def send_marker_message(self, recipient_id: str) -> None:
-        """Send a message that marks positions in the audio stream."""
-        pass
-
-
-class GenesysInputChannel(VoiceInputChannel):
-    @classmethod
-    def name(cls) -> str:
-        return "genesys"
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-    def _get_next_sequence(self) -> int:
-        """
-        Get the next message sequence number
-        Rasa == Server
-        Genesys == Client
-
-        Genesys requires the server and client each maintain a
-        monotonically increasing message sequence number.
-        """
-        cs = call_state
-        cs.server_sequence_number += 1  # type: ignore[attr-defined]
-        return cs.server_sequence_number
-
-    def _get_last_client_sequence(self) -> int:
-        """Get the last client(Genesys) sequence number."""
-        return call_state.client_sequence_number
-
-    def _update_client_sequence(self, seq: int) -> None:
-        """Update the client(Genesys) sequence number."""
-        if seq - call_state.client_sequence_number != 1:
-            logger.warning(
-                "genesys.update_client_sequence.sequence_gap",
-                received_seq=seq,
-                last_seq=call_state.client_sequence_number,
-            )
-        call_state.client_sequence_number = seq  # type: ignore[attr-defined]
-
-    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
-        return RasaAudioBytes(input_bytes)
-
-    async def collect_call_parameters(
-        self, channel_websocket: Websocket
-    ) -> Optional[CallParameters]:
-        """Call Parameters are collected during the open event."""
-        async for message in channel_websocket:
-            data = json.loads(message)
-            self._update_client_sequence(data["seq"])
-            if data.get("type") == "open":
-                call_params = await self.handle_open(channel_websocket, data)
-                return call_params
-            else:
-                logger.error("genesys.receive.unexpected_initial_message", message=data)
-
-        return None
-
-    def map_input_message(
-        self,
-        message: Any,
-        ws: Websocket,
-    ) -> VoiceChannelAction:
-        # if message is binary, it's audio
-        if isinstance(message, bytes):
-            return NewAudioAction(self.channel_bytes_to_rasa_audio_bytes(message))
-        else:
-            # process text message
-            data = json.loads(message)
-            self._update_client_sequence(data["seq"])
-            msg_type = data.get("type")
-            if msg_type == "close":
-                logger.info("genesys.handle_close", message=data)
-                self.handle_close(ws, data)
-                return EndConversationAction()
-            elif msg_type == "ping":
-                logger.info("genesys.handle_ping", message=data)
-                self.handle_ping(ws, data)
-            elif msg_type == "playback_started":
-                logger.debug("genesys.handle_playback_started", message=data)
-                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
-            elif msg_type == "playback_completed":
-                logger.debug("genesys.handle_playback_completed", message=data)
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
-                if call_state.should_hangup:
-                    logger.info("genesys.hangup")
-                    self.disconnect(ws, data)
-            elif msg_type == "dtmf":
-                logger.info("genesys.handle_dtmf", message=data)
-            elif msg_type == "error":
-                logger.warning("genesys.handle_error", message=data)
-            else:
-                logger.warning("genesys.map_input_message.unknown_type", message=data)
-
-        return ContinueConversationAction()
-
-    def create_output_channel(
-        self, voice_websocket: Websocket, tts_engine: TTSEngine
-    ) -> VoiceOutputChannel:
-        return GenesysOutputChannel(
-            voice_websocket,
-            tts_engine,
-            self.tts_cache,
-        )
-
-    async def handle_open(self, ws: Websocket, message: dict) -> CallParameters:
-        """Handle initial open transaction from Genesys."""
-        call_parameters = map_call_params(message)
-        params = message["parameters"]
-        media_options = params.get("media", [])
-
-        # Send opened response
-        if media_options:
-            logger.info("genesys.handle_open", media_parameter=media_options[0])
-            response = {
-                "version": "2",
-                "type": "opened",
-                "seq": self._get_next_sequence(),
-                "clientseq": self._get_last_client_sequence(),
-                "id": message.get("id"),
-                "parameters": {"startPaused": False, "media": [media_options[0]]},
-            }
-            logger.debug("genesys.handle_open.opened", response=response)
-            await ws.send(json.dumps(response))
-        else:
-            logger.warning(
-                "genesys.handle_open.no_media_formats", client_message=message
-            )
-        return call_parameters
-
-    def handle_ping(self, ws: Websocket, message: dict) -> None:
-        """Handle ping message from Genesys."""
-        response = {
-            "version": "2",
-            "type": "pong",
-            "seq": self._get_next_sequence(),
-            "clientseq": message.get("seq"),
-            "id": message.get("id"),
-            "parameters": {},
-        }
-        logger.debug("genesys.handle_ping.pong", response=response)
-        _schedule_ws_task(ws.send(json.dumps(response)))
-
-    def handle_close(self, ws: Websocket, message: dict) -> None:
-        """Handle close message from Genesys."""
-        response = {
-            "version": "2",
-            "type": "closed",
-            "seq": self._get_next_sequence(),
-            "clientseq": self._get_last_client_sequence(),
-            "id": message.get("id"),
-            "parameters": message.get("parameters", {}),
-        }
-        logger.debug("genesys.handle_close.closed", response=response)
-
-        _schedule_ws_task(ws.send(json.dumps(response)))
-        _schedule_ws_task(ws.close())
-
-    def disconnect(self, ws: Websocket, data: dict) -> None:
-        """
-        Send disconnect message to Genesys.
-
-        https://developer.genesys.cloud/devapps/audiohook/protocol-reference#disconnect
-        It should be used to hangup the call.
-        Genesys will respond with a "close" message to us
-        that is handled by the handle_close method.
-        """
-        message = {
-            "version": "2",
-            "type": "disconnect",
-            "seq": self._get_next_sequence(),
-            "clientseq": self._get_last_client_sequence(),
-            "id": data.get("id"),
-            "parameters": {
-                "reason": "completed",
-                # arbitrary values can be sent here
-            },
-        }
-        logger.debug("genesys.disconnect", message=message)
-        _schedule_ws_task(ws.send(json.dumps(message)))
-
-    def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> Blueprint:
-        """Defines a Sanic blueprint for the voice input channel."""
-        blueprint = Blueprint("genesys", __name__)
-
-        @blueprint.route("/", methods=["GET"])
-        async def health(_: Request) -> HTTPResponse:
-            return response.json({"status": "ok"})
-
-        @blueprint.websocket("/websocket")  # type: ignore[misc]
-        async def receive(request: Request, ws: Websocket) -> None:
-            logger.debug(
-                "genesys.receive",
-                audiohook_session_id=request.headers.get("audiohook-session-id"),
-            )
-            # validate required headers
-            required_headers = [
-                "audiohook-organization-id",
-                "audiohook-correlation-id",
-                "audiohook-session-id",
-                "x-api-key",
-            ]
-
-            for header in required_headers:
-                if header not in request.headers:
-                    await ws.close(1008, f"Missing required header: {header}")
-                    return
-
-            # TODO: validate API key header
-            # process audio streaming
-            logger.info("genesys.receive", message="Starting audio streaming")
-            await self.run_audio_streaming(on_new_message, ws)
-
-        return blueprint
-
-
-def _schedule_ws_task(coro: Awaitable[Any]) -> None:
-    """Helper function to schedule a coroutine in the event loop.
-
-    Args:
-        coro: The coroutine to schedule
-    """
-    loop = asyncio.get_running_loop()
-    loop.call_soon_threadsafe(lambda: loop.create_task(coro))

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -1,150 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-import structlog
-
-from rasa.dialogue_understanding.commands.command import Command
-from rasa.dialogue_understanding.patterns.cannot_handle import (
-    CannotHandlePatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.handle_digressions import (
-    HandleDigressionsPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.utils import (
-    top_flow_frame,
-    user_flows_on_the_stack,
-)
-from rasa.shared.core.events import Event
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.steps import CollectInformationFlowStep
-from rasa.shared.core.flows.utils import ALL_LABEL
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.nlu.constants import HANDLE_DIGRESSIONS_COMMAND
-
-structlogger = structlog.get_logger()
-
-
-@dataclass
-class HandleDigressionsCommand(Command):
-    """A command to handle digressions during an active flow."""
-
-    flow: str
-    """The interrupting flow."""
-
-    @classmethod
-    def command(cls) -> str:
-        """Returns the command type."""
-        return HANDLE_DIGRESSIONS_COMMAND
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> HandleDigressionsCommand:
-        """Converts the dictionary to a command.
-
-        Returns:
-            The converted dictionary.
-        """
-        try:
-            return HandleDigressionsCommand(flow=data["flow"])
-        except KeyError as e:
-            raise ValueError(
-                f"Missing parameter '{e}' while parsing HandleDigressionsCommand."
-            ) from e
-
-    def run_command_on_tracker(
-        self,
-        tracker: DialogueStateTracker,
-        all_flows: FlowsList,
-        original_tracker: DialogueStateTracker,
-    ) -> List[Event]:
-        """Runs the command on the tracker.
-
-        Args:
-            tracker: The tracker to run the command on.
-            all_flows: All flows in the assistant.
-            original_tracker: The tracker before any command was executed.
-
-        Returns:
-            The events to apply to the tracker.
-        """
-        stack = tracker.stack
-        original_stack = original_tracker.stack
-
-        if self.flow in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "command_executor.skip_command.already_started_flow", command=self
-            )
-            return []
-        elif self.flow not in all_flows.flow_ids:
-            structlogger.debug(
-                "command_executor.push_cannot_handle.start_invalid_flow_id",
-                command=self,
-            )
-            stack.push(CannotHandlePatternFlowStackFrame())
-            return tracker.create_stack_updated_events(stack)
-
-        # this allows to include called user flows in the stack search
-        latest_user_frame = top_flow_frame(original_stack, ignore_call_frames=False)
-
-        if latest_user_frame is None:
-            structlogger.debug(
-                "command_executor.skip_command.no_top_flow", command=self
-            )
-            return []
-
-        original_top_flow = latest_user_frame.flow(all_flows)
-        current_step = original_top_flow.step_by_id(latest_user_frame.step_id)
-        if not isinstance(current_step, CollectInformationFlowStep):
-            structlogger.debug(
-                "command_executor.skip_command.not_at_a_collect_step", command=self
-            )
-            return []
-
-        ask_confirm_digressions = set(
-            current_step.ask_confirm_digressions
-            + original_top_flow.ask_confirm_digressions
-        )
-
-        block_digressions = set(
-            current_step.block_digressions + original_top_flow.block_digressions
-        )
-
-        if block_digressions:
-            if ALL_LABEL in block_digressions:
-                block_digressions.remove(ALL_LABEL)
-                block_digressions.add(self.flow)
-
-        if ask_confirm_digressions:
-            if ALL_LABEL in ask_confirm_digressions:
-                ask_confirm_digressions.remove(ALL_LABEL)
-                ask_confirm_digressions.add(self.flow)
-
-        structlogger.debug(
-            "command_executor.push_handle_digressions",
-            interrupting_flow_id=self.flow,
-            interrupted_flow_id=original_top_flow.id,
-            interrupted_step_id=current_step.id,
-            ask_confirm_digressions=ask_confirm_digressions,
-            block_digressions=block_digressions,
-        )
-        stack.push(
-            HandleDigressionsPatternFlowStackFrame(
-                interrupting_flow_id=self.flow,
-                interrupted_flow_id=original_top_flow.id,
-                interrupted_step_id=current_step.id,
-                ask_confirm_digressions=ask_confirm_digressions,
-                block_digressions=block_digressions,
-            )
-        )
-
-        return tracker.create_stack_updated_events(stack)
-
-    def __hash__(self) -> int:
-        return hash(self.flow)
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, HandleDigressionsCommand):
-            return False
-
-        return other.flow == self.flow

rasa/dialogue_understanding/patterns/handle_digressions.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, Set
-
-from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
-
-FLOW_PATTERN_HANDLE_DIGRESSIONS = (
-    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "handle_digressions"
-)
-
-
-@dataclass
-class HandleDigressionsPatternFlowStackFrame(PatternFlowStackFrame):
-    """A pattern flow stack frame that gets added if an interruption is completed."""
-
-    flow_id: str = FLOW_PATTERN_HANDLE_DIGRESSIONS
-    """The ID of the flow."""
-    interrupting_flow_id: str = ""
-    """The ID of the flow that interrupted the active flow."""
-    interrupted_flow_id: str = ""
-    """The name of the active flow that was interrupted."""
-    interrupted_step_id: str = ""
-    """The ID of the step that was interrupted."""
-    ask_confirm_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to confirm."""
-    block_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to block."""
-
-    @classmethod
-    def type(cls) -> str:
-        """Returns the type of the frame."""
-        return FLOW_PATTERN_HANDLE_DIGRESSIONS
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> HandleDigressionsPatternFlowStackFrame:
-        """Creates a `DialogueStackFrame` from a dictionary.
-
-        Args:
-            data: The dictionary to create the `DialogueStackFrame` from.
-
-        Returns:
-            The created `DialogueStackFrame`.
-        """
-        return HandleDigressionsPatternFlowStackFrame(
-            frame_id=data["frame_id"],
-            step_id=data["step_id"],
-            interrupted_step_id=data["interrupted_step_id"],
-            interrupted_flow_id=data["interrupted_flow_id"],
-            interrupting_flow_id=data["interrupting_flow_id"],
-            ask_confirm_digressions=set(data.get(KEY_ASK_CONFIRM_DIGRESSIONS, [])),
-            # This attribute must be converted to a set to enable usage
-            # of subset `contains` pypred operator in the default pattern
-            # conditional branching
-            block_digressions=set(data.get(KEY_BLOCK_DIGRESSIONS, [])),
-        )
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, HandleDigressionsPatternFlowStackFrame):
-            return False
-        return (
-            self.flow_id == other.flow_id
-            and self.interrupted_step_id == other.interrupted_step_id
-            and self.interrupted_flow_id == other.interrupted_flow_id
-            and self.interrupting_flow_id == other.interrupting_flow_id
-            and self.ask_confirm_digressions == other.ask_confirm_digressions
-            and self.block_digressions == other.block_digressions
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
-        """Returns the frame as a dictionary."""
-        data = super().as_dict()
-        # converting back to list to avoid serialization issues
-        data[KEY_ASK_CONFIRM_DIGRESSIONS] = list(self.ask_confirm_digressions)
-        data[KEY_BLOCK_DIGRESSIONS] = list(self.block_digressions)
-        return data