rasa-pro 3.11.0rc2__py3-none-any.whl → 3.11.1__py3-none-any.whl

rasa/__main__.py

@@ -1,4 +1,5 @@
 import argparse
+from typing import Optional, List
 import structlog
 import os
 import platform
@@ -97,12 +98,17 @@ def print_version() -> None:
     print(f"License Expires   :         {get_license_expiration_date()}")
 
 
-def main() -> None:
-    """Run as standalone python application."""
+def main(raw_arguments: Optional[List[str]] = None) -> None:
+    """Run as standalone python application.
+
+    Args:
+        raw_arguments: Arguments to parse. If not provided,
+            arguments will be taken from the command line.
+    """
     warn_if_rasa_plus_package_installed()
     parse_last_positional_argument_as_model_path()
     arg_parser = create_argument_parser()
-    cmdline_arguments = arg_parser.parse_args()
+    cmdline_arguments = arg_parser.parse_args(raw_arguments)
 
     log_level = getattr(cmdline_arguments, "loglevel", None)
     logging_config_file = getattr(cmdline_arguments, "logging_config_file", None)

rasa/cli/studio/upload.py

@@ -32,25 +32,10 @@ def add_subparser(
     set_upload_arguments(upload_parser)
 
 
-def add_flows_param(
-    parser: argparse.ArgumentParser,
-    help_text: str = "Name of flows file to upload to Rasa Studio. Works with --calm",
-    default_path: str = "flows.yml",
-) -> None:
-    parser.add_argument(
-        "--flows",
-        default=default_path,
-        nargs="+",
-        type=str,
-        help=help_text,
-    )
-
-
 def set_upload_arguments(parser: argparse.ArgumentParser) -> None:
     """Add arguments for running `rasa upload`."""
     add_data_param(parser, data_type="training")
     add_domain_param(parser)
-    add_flows_param(parser)
     add_config_param(parser)
     add_endpoint_param(parser, help_text="Path to the endpoints file.")
 

rasa/cli/utils.py

@@ -305,7 +305,7 @@ def _validate_domain(validator: "Validator") -> bool:
     valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
     valid_form_slots = validator.verify_form_slots()
     valid_slot_mappings = validator.verify_slot_mappings()
-    valid_responses = validator.check_for_no_empty_paranthesis_in_responses()
+    valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
     valid_buttons = validator.validate_button_payloads()
     return (
         valid_domain_validity

rasa/core/channels/development_inspector.py

@@ -128,9 +128,12 @@ class DevelopmentInspectProxy(InputChannel):
 
             inspect_path = app.url_for(f"{app.name}.{underlying_webhook.name}.inspect")
 
+            # replace 0.0.0.0 with localhost
+            serve_location = app.serve_location.replace("0.0.0.0", "localhost")
+
             print_info(
                 f"Development inspector for channel {self.name()} is running. To "
-                f"inspect conversations, visit {app.serve_location}{inspect_path}"
+                f"inspect conversations, visit {serve_location}{inspect_path}"
             )
 
         underlying_webhook.add_websocket_route(
@@ -187,5 +190,8 @@ class TrackerStream:
         if not self._connected_clients:
             return
         await asyncio.wait(
-            [self._send(websocket, message) for websocket in self._connected_clients]
+            [
+                asyncio.create_task(self._send(websocket, message))
+                for websocket in self._connected_clients
+            ]
         )

rasa/core/channels/voice_ready/audiocodes.py

@@ -74,7 +74,7 @@ class Conversation:
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
         """Get metadata from the activity."""
-        return activity.get("parameters")
+        return asdict(map_call_params(activity["parameters"]))
 
     @staticmethod
     def _handle_event(event: Dict[Text, Any]) -> Text:
@@ -88,17 +88,16 @@ class Conversation:
 
         if event["name"] == EVENT_START:
             text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
-            event_params = asdict(map_call_params(event["parameters"]))
         elif event["name"] == EVENT_DTMF:
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_DTMF"
             event_params = {"value": event["value"]}
+            text += json.dumps(event_params)
         else:
             structlogger.warning(
                 "audiocodes.handle.event.unknown_event", event_payload=event
             )
             return ""
 
-        text += json.dumps(event_params)
         return text
 
     def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
@@ -384,7 +383,7 @@ class AudiocodesInput(InputChannel):
             {"conversation": <conversation_id>, "reason": Optional[Text]}.
             """
             self._get_conversation(request.token, conversation_id)
-            reason = json.dumps({"reason": request.json.get("reason")})
+            reason = {"reason": request.json.get("reason")}
             await on_new_message(
                 UserMessage(
                     text=f"{INTENT_MESSAGE_PREFIX}session_end",

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

@@ -1,5 +1,14 @@
 from dataclasses import dataclass
-from typing import Dict, AsyncIterator, Any, Generic, Optional, Type, TypeVar
+from typing import (
+    Dict,
+    AsyncIterator,
+    Any,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
 
 from websockets.legacy.client import WebSocketClientProtocol
 
@@ -7,6 +16,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import ASREvent
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.util import MergeableConfig
 from rasa.shared.exceptions import ConnectionException
+from rasa.shared.utils.common import validate_environment
 
 T = TypeVar("T", bound="ASREngineConfig")
 E = TypeVar("E", bound="ASREngine")
@@ -18,9 +28,17 @@ class ASREngineConfig(MergeableConfig):
 
 
 class ASREngine(Generic[T]):
+    required_env_vars: Tuple[str, ...] = ()
+    required_packages: Tuple[str, ...] = ()
+
     def __init__(self, config: Optional[T] = None):
         self.config = self.get_default_config().merge(config)
         self.asr_socket: Optional[WebSocketClientProtocol] = None
+        validate_environment(
+            self.required_env_vars,
+            self.required_packages,
+            f"ASR Engine {self.__class__.__name__}",
+        )
 
     async def connect(self) -> None:
         self.asr_socket = await self.open_websocket_connection()

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

@@ -14,5 +14,5 @@ class NewTranscript(ASREvent):
 
 
 @dataclass
-class UserStartedSpeaking(ASREvent):
+class UserIsSpeaking(ASREvent):
     pass

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

@@ -7,9 +7,10 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
+from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 
@@ -20,10 +21,14 @@ class AzureASRConfig(ASREngineConfig):
 
 
 class AzureASR(ASREngine[AzureASRConfig]):
+    required_env_vars = (AZURE_SPEECH_API_KEY_ENV_VAR,)
+    required_packages = ("azure.cognitiveservices.speech",)
+
     def __init__(self, config: Optional[AzureASRConfig] = None):
+        super().__init__(config)
+
         import azure.cognitiveservices.speech as speechsdk
 
-        super().__init__(config)
         self.speech_recognizer: Optional[speechsdk.SpeechRecognizer] = None
         self.stream: Optional[speechsdk.audio.PushAudioInputStream] = None
         self.is_recognizing = False
@@ -31,9 +36,13 @@ class AzureASR(ASREngine[AzureASRConfig]):
             asyncio.Queue()
         )
 
-    def signal_user_started_speaking(self, event: Any) -> None:
-        """Replace the unspecific azure event with a specific start event."""
-        self.fill_queue(UserStartedSpeaking())
+    @staticmethod
+    def validate_environment() -> None:
+        """Make sure all needed requirements for this component are met."""
+
+    def signal_user_is_speaking(self, event: Any) -> None:
+        """Replace the azure event with a generic is speaking event."""
+        self.fill_queue(UserIsSpeaking())
 
     def fill_queue(self, event: Any) -> None:
         """Either puts the event or a dedicated ASR Event into the queue."""
@@ -43,7 +52,7 @@ class AzureASR(ASREngine[AzureASRConfig]):
         import azure.cognitiveservices.speech as speechsdk
 
         speech_config = speechsdk.SpeechConfig(
-            subscription=os.environ["AZURE_SPEECH_API_KEY"],
+            subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
             region=self.config.speech_region,
         )
         audio_format = speechsdk.audio.AudioStreamFormat(
@@ -60,9 +69,7 @@ class AzureASR(ASREngine[AzureASRConfig]):
             audio_config=audio_config,
         )
         self.speech_recognizer.recognized.connect(self.fill_queue)
-        self.speech_recognizer.speech_start_detected.connect(
-            self.signal_user_started_speaking
-        )
+        self.speech_recognizer.recognizing.connect(self.signal_user_is_speaking)
         self.speech_recognizer.start_continuous_recognition_async()
         self.is_recognizing = True
 

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

@@ -10,11 +10,10 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
-
-DEEPGRAM_API_KEY = "DEEPGRAM_API_KEY"
+from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
 
 
 @dataclass
@@ -28,13 +27,15 @@ class DeepgramASRConfig(ASREngineConfig):
 
 
 class DeepgramASR(ASREngine[DeepgramASRConfig]):
+    required_env_vars = (DEEPGRAM_API_KEY_ENV_VAR,)
+
     def __init__(self, config: Optional[DeepgramASRConfig] = None):
         super().__init__(config)
         self.accumulated_transcript = ""
 
     async def open_websocket_connection(self) -> WebSocketClientProtocol:
         """Connect to the ASR system."""
-        deepgram_api_key = os.environ[DEEPGRAM_API_KEY]
+        deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
         extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
         api_url = self._get_api_url()
         query_params = self._get_query_params()
@@ -49,7 +50,7 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def _get_query_params(self) -> str:
         return (
             f"encoding=mulaw&sample_rate={HERTZ}&endpointing={self.config.endpointing}"
-            f"&vad_events=true&language={self.config.language}"
+            f"&vad_events=true&language={self.config.language}&interim_results=true"
             f"&model={self.config.model}&smart_format={str(self.config.smart_format).lower()}"
         )
 
@@ -66,16 +67,18 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""
         data = json.loads(e)
-        if data.get("is_final"):
+        if "is_final" in data:
             transcript = data["channel"]["alternatives"][0]["transcript"]
-            if data.get("speech_final"):
-                full_transcript = self.accumulated_transcript + transcript
-                self.accumulated_transcript = ""
-                return NewTranscript(full_transcript)
-            else:
-                self.accumulated_transcript += transcript
-        elif data.get("type") == "SpeechStarted":
-            return UserStartedSpeaking()
+            if data["is_final"]:
+                if data.get("speech_final"):
+                    full_transcript = self.accumulated_transcript + transcript
+                    self.accumulated_transcript = ""
+                    if full_transcript:
+                        return NewTranscript(full_transcript)
+                else:
+                    self.accumulated_transcript += transcript
+            elif transcript:
+                return UserIsSpeaking()
         return None
 
     @staticmethod

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

@@ -12,6 +12,7 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
     TTSEngineConfig,
     TTSError,
 )
+from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 
@@ -25,6 +26,7 @@ class AzureTTSConfig(TTSEngineConfig):
 
 class AzureTTS(TTSEngine[AzureTTSConfig]):
     session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (AZURE_SPEECH_API_KEY_ENV_VAR,)
 
     def __init__(self, config: Optional[AzureTTSConfig] = None):
         super().__init__(config)
@@ -66,7 +68,7 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
 
     @staticmethod
     def get_request_headers() -> dict[str, str]:
-        azure_speech_api_key = os.environ["AZURE_SPEECH_API_KEY"]
+        azure_speech_api_key = os.environ[AZURE_SPEECH_API_KEY_ENV_VAR]
         return {
             "Ocp-Apim-Subscription-Key": azure_speech_api_key,
             "Content-Type": "application/ssml+xml",

rasa/core/channels/voice_stream/tts/cartesia.py

@@ -11,12 +11,11 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
 
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
+from rasa.shared.constants import CARTESIA_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger()
 
-CARTESIA_API_KEY = "CARTESIA_API_KEY"
-
 
 @dataclass
 class CartesiaTTSConfig(TTSEngineConfig):
@@ -26,6 +25,7 @@ class CartesiaTTSConfig(TTSEngineConfig):
 
 class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
     session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (CARTESIA_API_KEY_ENV_VAR,)
 
     def __init__(self, config: Optional[CartesiaTTSConfig] = None):
         super().__init__(config)
@@ -62,7 +62,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
 
     @staticmethod
     def get_request_headers(config: CartesiaTTSConfig) -> dict[str, str]:
-        cartesia_api_key = os.environ[CARTESIA_API_KEY]
+        cartesia_api_key = os.environ[CARTESIA_API_KEY_ENV_VAR]
         return {
             "Cartesia-Version": str(config.version),
             "Content-Type": "application/json",

rasa/core/channels/voice_stream/tts/tts_engine.py

@@ -1,9 +1,10 @@
-from typing import AsyncIterator, Dict, Generic, Optional, Type, TypeVar
+from typing import AsyncIterator, Dict, Generic, Optional, Tuple, Type, TypeVar
 from dataclasses import dataclass
 
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.util import MergeableConfig
 from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.common import validate_environment
 
 
 class TTSError(RasaException):
@@ -22,8 +23,16 @@ class TTSEngineConfig(MergeableConfig):
 
 
 class TTSEngine(Generic[T]):
+    required_env_vars: Tuple[str, ...] = ()
+    required_packages: Tuple[str, ...] = ()
+
     def __init__(self, config: Optional[T] = None):
         self.config = self.get_default_config().merge(config)
+        validate_environment(
+            self.required_env_vars,
+            self.required_packages,
+            f"TTS Engine {self.__class__.__name__}",
+        )
 
     async def close_connection(self) -> None:
         """Cleanup the connection if necessary."""

rasa/core/channels/voice_stream/voice_channel.py

@@ -5,10 +5,7 @@ from dataclasses import asdict, dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
 
 from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import (
-    SILENCE_TIMEOUT_DEFAULT_VALUE,
-    SLOT_SILENCE_TIMEOUT,
-)
+from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
 from rasa.shared.utils.common import (
     class_from_module_path,
     mark_as_beta_feature,
@@ -24,7 +21,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from sanic import Websocket  # type: ignore
 
@@ -233,11 +230,18 @@ class VoiceOutputChannel(OutputChannel):
 
 
 class VoiceInputChannel(InputChannel):
-    def __init__(self, server_url: str, asr_config: Dict, tts_config: Dict):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+    ):
         validate_voice_license_scope()
         self.server_url = server_url
         self.asr_config = asr_config
         self.tts_config = tts_config
+        self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
     async def handle_silence_timeout(
@@ -247,10 +251,14 @@ class VoiceInputChannel(InputChannel):
         tts_engine: TTSEngine,
         call_parameters: CallParameters,
     ) -> None:
-        timeout = call_state.silence_timeout or SILENCE_TIMEOUT_DEFAULT_VALUE
-        logger.info("voice_channel.silence_timeout_watch_started", timeout=timeout)
+        timeout = call_state.silence_timeout
+        if not timeout:
+            return
+        if not self.monitor_silence:
+            return
+        logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
-        logger.info("voice_channel.silence_timeout_tripped")
+        logger.debug("voice_channel.silence_timeout_tripped")
         output_channel = self.create_output_channel(voice_websocket, tts_engine)
         message = UserMessage(
             "/silence_timeout",
@@ -261,10 +269,23 @@ class VoiceInputChannel(InputChannel):
         )
         await on_new_message(message)
 
+    @staticmethod
+    def _cancel_silence_timeout_watcher() -> None:
+        """Cancels the silent timeout task if it exists."""
+        if call_state.silence_timeout_watcher:
+            logger.debug("voice_channel.cancelling_current_timeout_watcher_task")
+            call_state.silence_timeout_watcher.cancel()
+            call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
         credentials = credentials or {}
-        return cls(credentials["server_url"], credentials["asr"], credentials["tts"])
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+        )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         raise NotImplementedError
@@ -323,11 +344,14 @@ class VoiceInputChannel(InputChannel):
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:
-                    logger.info("voice_channel.bot_started_speaking")
+                    logger.debug("voice_channel.bot_started_speaking")
+                    # relevant when the bot speaks multiple messages in one turn
+                    self._cancel_silence_timeout_watcher()
 
                 # we just stopped speaking, starting a watcher for silence timeout
                 if is_bot_speaking_before and not is_bot_speaking_after:
-                    logger.info("voice_channel.bot_stopped_speaking")
+                    logger.debug("voice_channel.bot_stopped_speaking")
+                    self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
                             self.handle_silence_timeout(
@@ -354,12 +378,20 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
+        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
+        asr_event_task = asyncio.create_task(consume_asr_events())
         await asyncio.wait(
-            [consume_audio_bytes(), consume_asr_events()],
+            [audio_forwarding_task, asr_event_task],
             return_when=asyncio.FIRST_COMPLETED,
         )
+        if not audio_forwarding_task.done():
+            audio_forwarding_task.cancel()
+        if not asr_event_task.done():
+            asr_event_task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
+        await channel_websocket.close()
+        self._cancel_silence_timeout_watcher()
 
     def create_output_channel(
         self, voice_websocket: Websocket, tts_engine: TTSEngine
@@ -377,7 +409,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         """Handle a new event from the ASR system."""
         if isinstance(e, NewTranscript) and e.text:
-            logger.info(
+            logger.debug(
                 "VoiceInputChannel.handle_asr_event.new_transcript", transcript=e.text
             )
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
@@ -390,8 +422,6 @@ class VoiceInputChannel(InputChannel):
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
-        elif isinstance(e, UserStartedSpeaking):
-            if call_state.silence_timeout_watcher:
-                call_state.silence_timeout_watcher.cancel()
-                call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+        elif isinstance(e, UserIsSpeaking):
+            self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]

rasa/core/information_retrieval/qdrant.py

@@ -62,6 +62,7 @@ class Qdrant_Store(InformationRetrieval):
             embeddings=self.embeddings,
             content_payload_key=params.get("content_payload_key", "text"),
             metadata_payload_key=params.get("metadata_payload_key", "metadata"),
+            vector_name=params.get("vector_name", None),
         )
 
     async def search(

rasa/core/nlg/contextual_response_rephraser.py

@@ -13,7 +13,7 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import BotUttered, UserUttered
@@ -253,7 +253,7 @@ class ContextualResponseRephraser(
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
         if not (updated_text := await self._generate_llm_response(prompt)):
             # If the LLM fails to generate a response, we