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

rasa/core/actions/action_handle_digressions.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.core.utils import add_bot_utterance_metadata
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.handle_digressions import (
+    HandleDigressionsPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.shared.core.constants import (
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+class ActionBlockDigressions(Action):
+    """Action which blocks an interruption and continues the current flow."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_BLOCK_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_block_digressions.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.REGULAR
+
+        stack = tracker.stack
+        stack.push(
+            UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type), 0
+        )
+        stack.push(
+            ContinueInterruptedPatternFlowStackFrame(
+                previous_flow_name=blocked_flow_id
+            ),
+            1,
+        )
+        events = tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_block_digressions"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_block_digressions.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events
+
+
+class ActionContinueDigression(Action):
+    """Action which continues with an interruption."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_CONTINUE_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_continue_digression.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.INTERRUPT
+        stack = tracker.stack
+        stack.push(UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type))
+
+        events = [
+            FlowInterrupted(
+                flow_id=top_frame.interrupted_flow_id,
+                step_id=top_frame.interrupted_step_id,
+            )
+        ] + tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_continue_interruption"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_continue_digression.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events

rasa/core/actions/action_run_slot_rejections.py

@@ -9,14 +9,17 @@ from rasa.core.utils import add_bot_utterance_metadata
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.shared.core.constants import ACTION_RUN_SLOT_REJECTIONS_NAME
 from rasa.shared.core.events import Event, SlotSet
-from rasa.shared.core.flows.steps.collect import SlotRejection
 from rasa.shared.core.slots import (
     BooleanSlot,
     CategoricalSlot,
     FloatSlot,
     Slot,
+    SlotRejection,
 )
 
 if TYPE_CHECKING:
@@ -138,10 +141,19 @@ class ActionRunSlotRejections(Action):
         """Run the predicate checks."""
         utterance = None
         top_frame = tracker.stack.top()
-        if not isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+        if not isinstance(
+            top_frame,
+            (
+                CollectInformationPatternFlowStackFrame,
+                ValidateSlotPatternFlowStackFrame,
+            ),
+        ):
             return []
+        elif isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            slot_name = top_frame.collect
+        elif isinstance(top_frame, ValidateSlotPatternFlowStackFrame):
+            slot_name = top_frame.validate
 
-        slot_name = top_frame.collect
         slot_instance = tracker.slots.get(slot_name)
         if slot_instance and not slot_instance.has_been_set:
             # this is the first time the assistant asks for the slot value,
@@ -205,6 +217,6 @@ class ActionRunSlotRejections(Action):
             message = add_bot_utterance_metadata(
                 message, utterance, nlg, domain, tracker
             )
-            events.append(create_bot_utterance(message))
+            events.append(create_bot_utterance(message, tracker.current_language))
 
         return events

rasa/core/actions/forms.py

@@ -2,7 +2,7 @@ import copy
 import itertools
 import json
 import logging
-from typing import Any, Dict, List, Optional, Set, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
 
@@ -16,7 +16,7 @@ from rasa.shared.constants import UTTER_PREFIX
 from rasa.shared.core.constants import (
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
-    MAPPING_TYPE,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -35,6 +35,9 @@ from rasa.shared.core.slots import ListSlot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
 
+if TYPE_CHECKING:
+    from rasa.shared.core.slot_mappings import SlotMapping
+
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
@@ -158,7 +161,9 @@ class FormAction(LoopAction):
         domain_slots = domain.as_dict().get(KEY_SLOTS, {})
         for slot in domain.required_slots_for_form(self.name()):
             for slot_mapping in domain_slots.get(slot, {}).get(SLOT_MAPPINGS, []):
-                if slot_mapping.get(MAPPING_TYPE) == str(SlotMappingType.FROM_ENTITY):
+                if slot_mapping.get(KEY_MAPPING_TYPE) == str(
+                    SlotMappingType.FROM_ENTITY
+                ):
                     mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
                     if mapping_as_string in unique_entity_slot_mappings:
                         unique_entity_slot_mappings.remove(mapping_as_string)
@@ -169,7 +174,7 @@ class FormAction(LoopAction):
         return unique_entity_slot_mappings
 
     def entity_mapping_is_unique(
-        self, slot_mapping: Dict[Text, Any], domain: Domain
+        self, slot_mapping: "SlotMapping", domain: Domain
     ) -> bool:
         """Verifies if the from_entity mapping is unique."""
         if not self._have_unique_entity_mappings_been_initialized:
@@ -177,7 +182,7 @@ class FormAction(LoopAction):
             self._unique_entity_mappings = self._create_unique_entity_mappings(domain)
             self._have_unique_entity_mappings_been_initialized = True
 
-        mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
+        mapping_as_string = json.dumps(slot_mapping.as_dict(), sort_keys=True)
         return mapping_as_string in self._unique_entity_mappings
 
     @staticmethod

rasa/core/channels/__init__.py

@@ -32,7 +32,9 @@ from rasa.core.channels.vier_cvg import CVGInput
 from rasa.core.channels.voice_stream.twilio_media_streams import (
     TwilioMediaStreamsInputChannel,
 )
+from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.core.channels.voice_stream.audiocodes import AudiocodesVoiceInputChannel
 
 input_channel_classes: List[Type[InputChannel]] = [
     CmdlineInput,
@@ -55,7 +57,9 @@ input_channel_classes: List[Type[InputChannel]] = [
     JambonzVoiceReadyInput,
     TwilioMediaStreamsInputChannel,
     BrowserAudioInputChannel,
+    GenesysInputChannel,
     StudioChatInput,
+    AudiocodesVoiceInputChannel,
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/studio_chat.py

@@ -18,6 +18,8 @@ from sanic import Sanic
 from rasa.core.channels.socketio import SocketBlueprint, SocketIOInput
 from rasa.hooks import hookimpl
 from rasa.plugin import plugin_manager
+from rasa.shared.core.constants import ACTION_LISTEN_NAME
+from rasa.shared.core.events import ActionExecuted
 from rasa.shared.core.trackers import EventVerbosity
 
 if TYPE_CHECKING:
@@ -43,6 +45,15 @@ def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
     return json.dumps(state)
 
 
+def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
+    """Check if the tracker needs an action prediction."""
+    return (
+        len(tracker.events) == 0
+        or not isinstance(tracker.events[-1], ActionExecuted)
+        or tracker.events[-1].action_name != ACTION_LISTEN_NAME
+    )
+
+
 class StudioTrackerUpdatePlugin:
     """Plugin for publishing tracker updates a socketio channel."""
 
@@ -169,6 +180,14 @@ class StudioChatInput(SocketIOInput):
             # will override an existing tracker with the same id!
             await self.agent.tracker_store.save(tracker)
 
+            processor = self.agent.processor
+            if processor and does_need_action_prediction(tracker):
+                output_channel = self.get_output_channel()
+
+                await processor._run_prediction_loop(output_channel, tracker)
+                await processor.run_anonymization_pipeline(tracker)
+                await self.agent.tracker_store.save(tracker)
+
         await self.on_tracker_updated(tracker)
 
     def blueprint(

rasa/core/channels/telegram.py

@@ -1,21 +1,9 @@
 import json
 import logging
+import typing
 from copy import deepcopy
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
-from aiogram import Bot
-from aiogram.exceptions import TelegramAPIError
-from aiogram.types import (
-    InlineKeyboardButton,
-    KeyboardButton,
-    Message,
-    Update,
-)
-from aiogram.utils.keyboard import (
-    InlineKeyboardBuilder,
-    KeyboardBuilder,
-    ReplyKeyboardBuilder,
-)
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
@@ -27,8 +15,11 @@ from rasa.shared.exceptions import RasaException
 
 logger = logging.getLogger(__name__)
 
+if typing.TYPE_CHECKING:
+    from aiogram.types import Message, Update
 
-class TelegramOutput(Bot, OutputChannel):
+
+class TelegramOutput(OutputChannel):
     """Output channel for Telegram."""
 
     # skipcq: PYL-W0236
@@ -37,20 +28,28 @@ class TelegramOutput(Bot, OutputChannel):
         return "telegram"
 
     def __init__(self, access_token: Optional[Text]) -> None:
-        Bot.__init__(self, access_token)
+        try:
+            from aiogram import Bot
+
+            self.bot = Bot(access_token)
+        except ImportError:
+            raise ImportError(
+                "To use the Telegram channel, please install the aiogram package "
+                "with 'pip install aiogram'"
+            )
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Sends text message."""
         for message_part in text.strip().split("\n\n"):
-            await self.send_message(recipient_id, message_part)
+            await self.bot.send_message(recipient_id, message_part)
 
     async def send_image_url(
         self, recipient_id: Text, image: Text, **kwargs: Any
     ) -> None:
         """Sends an image."""
-        await self.send_photo(recipient_id, image)
+        await self.bot.send_photo(recipient_id, image)
 
     async def send_text_with_buttons(
         self,
@@ -70,8 +69,15 @@ class TelegramOutput(Bot, OutputChannel):
 
         :button_type reply: reply keyboard
         """
+        from aiogram.types import InlineKeyboardButton, KeyboardButton
+        from aiogram.utils.keyboard import (
+            InlineKeyboardBuilder,
+            KeyboardBuilder,
+            ReplyKeyboardBuilder,
+        )
+
         if button_type == "inline":
-            reply_markup_builder: KeyboardBuilder = InlineKeyboardBuilder()
+            reply_markup_builder: "KeyboardBuilder" = InlineKeyboardBuilder()
             button_list = [
                 InlineKeyboardButton(text=s["title"], callback_data=s["payload"])
                 for s in buttons
@@ -110,7 +116,7 @@ class TelegramOutput(Bot, OutputChannel):
             )
             return
 
-        await self.send_message(recipient_id, text, reply_markup=reply_markup)
+        await self.bot.send_message(recipient_id, text, reply_markup=reply_markup)
 
     async def send_custom_json(
         self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
@@ -150,9 +156,17 @@ class TelegramOutput(Bot, OutputChannel):
         for params in send_functions.keys():
             if all(json_message.get(p) is not None for p in params):
                 args = [json_message.pop(p) for p in params]
-                api_call = getattr(self, send_functions[params])
+                api_call = getattr(self.bot, send_functions[params])
                 await api_call(recipient_id, *args, **json_message)
 
+    async def get_me(self) -> Any:
+        """Get information about the bot itself."""
+        return await self.bot.get_me()
+
+    async def set_webhook(self, url: Text) -> None:
+        """Set the webhook URL for telegram."""
+        await self.bot.set_webhook(url=url)
+
 
 class TelegramInput(InputChannel):
     """Telegram input channel."""
@@ -185,19 +199,19 @@ class TelegramInput(InputChannel):
         self.debug_mode = debug_mode
 
     @staticmethod
-    def _is_location(message: Message) -> bool:
+    def _is_location(message: "Message") -> bool:
         return message.location is not None
 
     @staticmethod
-    def _is_user_message(message: Message) -> bool:
+    def _is_user_message(message: "Message") -> bool:
         return message.text is not None
 
     @staticmethod
-    def _is_edited_message(message: Update) -> bool:
+    def _is_edited_message(message: "Update") -> bool:
         return message.edited_message is not None
 
     @staticmethod
-    def _is_button(message: Update) -> bool:
+    def _is_button(message: "Update") -> bool:
         return message.callback_query is not None
 
     def blueprint(
@@ -223,6 +237,8 @@ class TelegramInput(InputChannel):
 
         @telegram_webhook.route("/webhook", methods=["GET", "POST"])
         async def message(request: Request) -> Any:
+            from aiogram.types import Update
+
             if request.method == "POST":
                 request_dict = request.json
                 if isinstance(request_dict, Text):
@@ -322,6 +338,8 @@ class TelegramInput(InputChannel):
         return TelegramOutput(self.access_token)
 
     async def set_webhook(self, channel: TelegramOutput) -> None:
+        from aiogram.exceptions import TelegramAPIError
+
         try:
             await channel.set_webhook(url=self.webhook_url)
         except TelegramAPIError as error:

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,9 +1,11 @@
+import asyncio
 import copy
 import json
 import uuid
+from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -223,6 +225,16 @@ class AudiocodesInput(InputChannel):
         self.scheduler_job = None
         self.keep_alive = keep_alive
         self.keep_alive_expiration_factor = keep_alive_expiration_factor
+        self.background_tasks: Dict[Text, Set[asyncio.Task]] = defaultdict(set)
+
+    def _create_task(self, conversation_id: Text, coro: Awaitable[Any]) -> asyncio.Task:
+        """Create and track an asyncio task for a conversation."""
+        task: asyncio.Task = asyncio.create_task(coro)
+        self.background_tasks[conversation_id].add(task)
+        task.add_done_callback(
+            lambda t: self.background_tasks[conversation_id].discard(t)
+        )
+        return task
 
     async def _set_scheduler_job(self) -> None:
         if self.scheduler_job:
@@ -251,11 +263,20 @@ class AudiocodesInput(InputChannel):
         )
         now = datetime.now(timezone.utc)
         delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
-        self.conversations = {
-            k: v
-            for k, v in self.conversations.items()
-            if v.is_active_conversation(now, delta)
-        }
+
+        # clean up conversations
+        inactive = [
+            conv_id
+            for conv_id, conv in self.conversations.items()
+            if not conv.is_active_conversation(now, delta)
+        ]
+
+        # cancel tasks and remove conversations
+        for conv_id in inactive:
+            for task in self.background_tasks[conv_id]:
+                task.cancel()
+            self.background_tasks.pop(conv_id, None)
+            self.conversations.pop(conv_id, None)
 
     def handle_start_conversation(self, body: Dict[Text, Any]) -> Dict[Text, Any]:
         conversation_id = body["conversation"]
@@ -347,31 +368,29 @@ class AudiocodesInput(InputChannel):
             structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
+                structlogger.warning(
+                    "audiocodes.on_activities.no_conversation", request=request.json
+                )
                 return response.json({})
             elif conversation.ws:
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json({})
+                response_json = {}
             else:
                 # handle non websocket case where messages get returned in json
                 ac_output = AudiocodesOutput()
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json(
-                    {
-                        "conversation": conversation_id,
-                        "activities": ac_output.messages,
-                    }
-                )
+                response_json = {
+                    "conversation": conversation_id,
+                    "activities": ac_output.messages,
+                }
+
+            # start a background task to handle activities
+            self._create_task(
+                conversation_id,
+                conversation.handle_activities(request.json, ac_output, on_new_message),
+            )
+            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/core/channels/voice_ready/utils.py

@@ -29,7 +29,7 @@ class CallParameters:
 
     call_id: str
     user_phone: str
-    bot_phone: str
+    bot_phone: Optional[str] = None
     user_name: Optional[str] = None
     user_host: Optional[str] = None
     bot_host: Optional[str] = None

rasa/core/channels/voice_stream/asr/asr_engine.py

@@ -10,6 +10,7 @@ from typing import (
     TypeVar,
 )
 
+import structlog
 from websockets.legacy.client import WebSocketClientProtocol
 
 from rasa.core.channels.voice_stream.asr.asr_event import ASREvent
@@ -20,6 +21,7 @@ from rasa.shared.utils.common import validate_environment
 
 T = TypeVar("T", bound="ASREngineConfig")
 E = TypeVar("E", bound="ASREngine")
+logger = structlog.get_logger(__name__)
 
 
 @dataclass
@@ -74,10 +76,14 @@ class ASREngine(Generic[T]):
         """Stream the events returned by the ASR system as it is fed audio bytes."""
         if self.asr_socket is None:
             raise ConnectionException("Websocket not connected.")
-        async for message in self.asr_socket:
-            asr_event = self.engine_event_to_asr_event(message)
-            if asr_event:
-                yield asr_event
+
+        try:
+            async for message in self.asr_socket:
+                asr_event = self.engine_event_to_asr_event(message)
+                if asr_event:
+                    yield asr_event
+        except Exception as e:
+            logger.warning(f"Error while streaming ASR events: {e}")
 
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""

rasa/core/channels/voice_stream/asr/azure.py

@@ -18,6 +18,8 @@ from rasa.shared.exceptions import ConnectionException
 class AzureASRConfig(ASREngineConfig):
     language: Optional[str] = None
     speech_region: Optional[str] = None
+    speech_host: Optional[str] = None
+    speech_endpoint: Optional[str] = None
 
 
 class AzureASR(ASREngine[AzureASRConfig]):
@@ -52,9 +54,18 @@ class AzureASR(ASREngine[AzureASRConfig]):
     async def connect(self) -> None:
         import azure.cognitiveservices.speech as speechsdk
 
+        # connecting to eastus by default
+        if (
+            self.config.speech_region is None
+            and self.config.speech_host is None
+            and self.config.speech_endpoint is None
+        ):
+            self.config.speech_region = "eastus"
         speech_config = speechsdk.SpeechConfig(
             subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
             region=self.config.speech_region,
+            endpoint=self.config.speech_endpoint,
+            host=self.config.speech_host,
         )
         audio_format = speechsdk.audio.AudioStreamFormat(
             samples_per_second=HERTZ,
@@ -123,7 +134,9 @@ class AzureASR(ASREngine[AzureASRConfig]):
 
     @staticmethod
     def get_default_config() -> AzureASRConfig:
-        return AzureASRConfig("en-US", "eastus")
+        return AzureASRConfig(
+            language=None, speech_region=None, speech_host=None, speech_endpoint=None
+        )
 
     @classmethod
     def from_config_dict(cls, config: Dict) -> "AzureASR":