rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc2__py3-none-any.whl

rasa/core/actions/action_handle_digressions.py

@@ -18,6 +18,10 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
     UserFlowStackFrame,
 )
+from rasa.dialogue_understanding.stack.utils import (
+    remove_digression_from_stack,
+    user_flows_on_the_stack,
+)
 from rasa.shared.core.constants import (
     ACTION_BLOCK_DIGRESSION,
     ACTION_CONTINUE_DIGRESSION,
@@ -55,16 +59,24 @@ class ActionBlockDigressions(Action):
         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)
+
+        if blocked_flow_id in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "action_block_digressions.already_blocked_flow",
+                blocked_flow_id=blocked_flow_id,
+            )
+            events = []
+        else:
+            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(
@@ -109,10 +121,20 @@ class ActionContinueDigression(Action):
         if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
             return []
 
-        blocked_flow_id = top_frame.interrupting_flow_id
-        frame_type = FlowStackFrameType.INTERRUPT
+        interrupting_flow_id = top_frame.interrupting_flow_id
         stack = tracker.stack
-        stack.push(UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type))
+
+        if interrupting_flow_id in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "action_continue_digression.interrupting_flow_id_already_on_the_stack",
+                interrupting_flow_id=interrupting_flow_id,
+            )
+            stack = remove_digression_from_stack(stack, interrupting_flow_id)
+
+        frame_type = FlowStackFrameType.INTERRUPT
+        stack.push(
+            UserFlowStackFrame(flow_id=interrupting_flow_id, frame_type=frame_type)
+        )
 
         events = [
             FlowInterrupted(

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/channels/__init__.py

@@ -34,6 +34,7 @@ from rasa.core.channels.voice_stream.twilio_media_streams import (
 )
 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,
@@ -58,6 +59,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     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/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":

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

@@ -4,7 +4,9 @@ from dataclasses import dataclass
 from typing import Any, Dict, Optional
 from urllib.parse import urlencode
 
+import structlog
 import websockets
+import websockets.exceptions
 from websockets.legacy.client import WebSocketClientProtocol
 
 from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
@@ -16,6 +18,8 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
 
+logger = structlog.get_logger(__name__)
+
 
 @dataclass
 class DeepgramASRConfig(ASREngineConfig):
@@ -41,10 +45,22 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
         """Connect to the ASR system."""
         deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
         extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
-        return await websockets.connect(  # type: ignore
-            self._get_api_url_with_query_params(),
-            extra_headers=extra_headers,
-        )
+        try:
+            return await websockets.connect(  # type: ignore
+                self._get_api_url_with_query_params(),
+                extra_headers=extra_headers,
+            )
+        except websockets.exceptions.InvalidStatusCode as e:
+            if e.status_code == 401:
+                error_msg = "Please make sure your Deepgram API key is correct."
+            else:
+                error_msg = "Connection to Deepgram failed."
+            logger.error(
+                "deepgram.connection.failed",
+                status_code=e.status_code,
+                error=error_msg,
+            )
+            raise
 
     def _get_api_url_with_query_params(self) -> str:
         """Combine api url and query params."""