rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.13.0a1.dev1__py3-none-any.whl

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,7 +14,7 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
@@ -102,16 +102,22 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ):
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.username = username
         self.password = password
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> VoiceInputChannel:
         credentials = credentials or {}
 
         username = credentials.get("username")
@@ -126,7 +132,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             credentials["server_url"],
             credentials["asr"],
             credentials["tts"],
-            credentials.get("monitor_silence", False),
             username=username,
             password=password,
         )

rasa/core/channels/voice_stream/voice_channel.py

@@ -31,8 +31,10 @@ from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
-from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
+from rasa.core.channels.voice_stream.util import (
+    generate_silence,
+)
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.common import (
     class_from_module_path,
@@ -42,6 +44,11 @@ from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
 
+# define constants for the voice channel
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
+
 
 @dataclass
 class VoiceChannelAction:
@@ -166,8 +173,12 @@ class VoiceOutputChannel(OutputChannel):
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
-            call_state.silence_timeout = (  # type: ignore[attr-defined]
-                self.tracker_state["slots"][SLOT_SILENCE_TIMEOUT]
+            call_state.silence_timeout = self.tracker_state["slots"][  # type: ignore[attr-defined]
+                SILENCE_TIMEOUT_SLOT
+            ]
+            logger.debug(
+                "voice_channel.silence_timeout_updated",
+                silence_timeout=call_state.silence_timeout,
             )
 
     async def send_text_with_buttons(
@@ -189,6 +200,7 @@ class VoiceOutputChannel(OutputChannel):
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
         last_sent_offset = 0
+        logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
         try:
@@ -274,26 +286,34 @@ class VoiceOutputChannel(OutputChannel):
 
 
 class VoiceInputChannel(InputChannel):
+    # All children of this class require a voice license to be used.
+    requires_voice_license = True
+
     def __init__(
         self,
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
     ):
-        validate_voice_license_scope()
+        if self.requires_voice_license:
+            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))
 
+        logger.info(
+            "voice_channel.initialized",
+            server_url=self.server_url,
+            asr_config=self.asr_config,
+            tts_config=self.tts_config,
+        )
+
     async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         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)
         await asr_event_queue.put(UserSilence())
@@ -308,13 +328,15 @@ class VoiceInputChannel(InputChannel):
             call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> InputChannel:
         credentials = credentials or {}
         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:
@@ -334,9 +356,9 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            "/session_start",
-            output_channel,
-            call_parameters.stream_id,
+            text=USER_CONVERSATION_SESSION_START,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
             input_channel=self.name(),
             metadata=asdict(call_parameters),
         )
@@ -371,17 +393,17 @@ class VoiceInputChannel(InputChannel):
 
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
-                is_bot_speaking_before = call_state.is_bot_speaking
+                was_bot_speaking_before = call_state.is_bot_speaking
                 channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
-                if not is_bot_speaking_before and is_bot_speaking_after:
+                if not was_bot_speaking_before and is_bot_speaking_after:
                     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:
+                if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
@@ -393,6 +415,9 @@ class VoiceInputChannel(InputChannel):
                     await asr_engine.send_audio_chunks(channel_action.audio_bytes)
                 elif isinstance(channel_action, EndConversationAction):
                     # end stream event came from the other side
+                    await self.handle_disconnect(
+                        channel_websocket, on_new_message, tts_engine, call_parameters
+                    )
                     break
 
         async def receive_asr_events() -> None:
@@ -449,9 +474,9 @@ class VoiceInputChannel(InputChannel):
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                e.text,
-                output_channel,
-                call_parameters.stream_id,
+                text=e.text,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
@@ -462,10 +487,27 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                "/silence_timeout",
-                output_channel,
-                call_parameters.stream_id,
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
+
+    async def handle_disconnect(
+        self,
+        channel_websocket: Websocket,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        tts_engine: TTSEngine,
+        call_parameters: CallParameters,
+    ) -> None:
+        """Handle disconnection from the channel."""
+        output_channel = self.create_output_channel(channel_websocket, tts_engine)
+        message = UserMessage(
+            text=USER_CONVERSATION_SESSION_END,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
+            input_channel=self.name(),
+        )
+        await on_new_message(message)

rasa/core/concurrent_lock_store.py

@@ -1,9 +1,10 @@
 import json
-import logging
 import time
 from collections import deque
 from typing import Deque, Optional, Text
 
+import structlog
+
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -19,7 +20,7 @@ DEFAULT_PORT = 6379
 
 DEFAULT_HOSTNAME = "localhost"
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 LAST_ISSUED_TICKET_NUMBER_SUFFIX = "last_issued_ticket_number"
 
@@ -105,7 +106,10 @@ class ConcurrentRedisLockStore(LockStore):
 
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
+            structlogger.debug(
+                "concurrent_redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=f"Setting non-default redis key prefix: '{key_prefix}'.",
+            )
             self._set_key_prefix(key_prefix)
 
         super().__init__()
@@ -116,9 +120,13 @@ class ConcurrentRedisLockStore(LockStore):
                 key_prefix + ":" + DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
             )
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "concurrent_redis_lock_store._set_key_prefix.default_instead_of_invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def issue_ticket(
@@ -129,7 +137,10 @@ class ConcurrentRedisLockStore(LockStore):
         It's configured with `lock_lifetime` and associated with `conversation_id`.
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "concurrent_redis_lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             lock.remove_expired_tickets()
@@ -164,9 +175,12 @@ class ConcurrentRedisLockStore(LockStore):
         redis_keys = self.red.keys(pattern)
 
         if not redis_keys:
-            logger.debug(
-                f"The lock store does not contain any key-value "
-                f"items for conversation '{conversation_id}'."
+            structlogger.debug(
+                "concurrent_redis_lock_store.delete_lock_key_not_found",
+                event_info=(
+                    f"The lock store does not contain any key-value "
+                    f"items for conversation '{conversation_id}'."
+                ),
             )
             return None
 

rasa/core/evaluation/marker_tracker_loader.py

@@ -2,7 +2,7 @@ import random
 from typing import Any, AsyncIterator, Iterable, List, Optional, Text
 
 import rasa.shared.utils.io
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
 

rasa/core/exporter.py

@@ -10,7 +10,7 @@ import rasa.shared.utils.io
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.brokers.pika import PikaEventBroker
 from rasa.core.constants import RASA_EXPORT_PROCESS_ID_HEADER_NAME
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.exceptions import (
     NoConversationsInTrackerStoreError,
     NoEventsToMigrateError,

rasa/core/http_interpreter.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 from typing import Any, Dict, Optional, Text
 
@@ -49,7 +48,6 @@ class RasaNLUHttpInterpreter:
         if not self.endpoint_config or self.endpoint_config.url is None:
             structlogger.error(
                 "http.parse.text",
-                text=copy.deepcopy(text),
                 event_info="No rasa NLU server specified!",
             )
             return None
@@ -71,18 +69,16 @@ class RasaNLUHttpInterpreter:
                 if resp.status == 200:
                     return await resp.json()
                 else:
-                    response_text = await resp.text()
                     structlogger.error(
                         "http.parse.text.failure",
-                        text=copy.deepcopy(text),
-                        response_text=copy.deepcopy(response_text),
+                        event_info="Failed to parse text",
                     )
                     return None
-        except Exception:  # skipcq: PYL-W0703
+        except Exception as e:  # skipcq: PYL-W0703
             # need to catch all possible exceptions when doing http requests
             # (timeouts, value errors, parser errors, ...)
             structlogger.exception(
                 "http.parse.text.exception",
-                text=copy.deepcopy(text),
+                event_info=f"Exception occurred while parsing text. Error: {e}",
             )
             return None

rasa/core/information_retrieval/faiss.py

@@ -12,6 +12,7 @@ from rasa.core.information_retrieval import (
     InformationRetrievalException,
     SearchResultList,
 )
+from rasa.core.information_retrieval.ingestion.faq_parser import _format_faq_documents
 from rasa.utils.endpoints import EndpointConfig
 from rasa.utils.ml_utils import persist_faiss_vector_store
 
@@ -31,10 +32,12 @@ class FAISS_Store(InformationRetrieval):
         index_path: str,
         docs_folder: Optional[str],
         create_index: Optional[bool] = False,
+        parse_as_faq_pairs: Optional[bool] = False,
     ):
         """Initializes the FAISS Store."""
         self.chunk_size = 1000
         self.chunk_overlap = 20
+        self.parse_as_faq_pairs = parse_as_faq_pairs
 
         path = Path(index_path) / "documents_faiss"
         if create_index:
@@ -86,21 +89,25 @@ class FAISS_Store(InformationRetrieval):
         if not docs_folder:
             raise ValueError("parameter `docs_folder` needs to be specified")
 
-        docs = self.load_documents(docs_folder)
-        splitter = RecursiveCharacterTextSplitter(
-            chunk_size=self.chunk_size,
-            chunk_overlap=self.chunk_overlap,
-            length_function=len,
-        )
-        doc_chunks = splitter.split_documents(docs)
+        documents = self.load_documents(docs_folder)
+
+        if not self.parse_as_faq_pairs:
+            splitter = RecursiveCharacterTextSplitter(
+                chunk_size=self.chunk_size,
+                chunk_overlap=self.chunk_overlap,
+                length_function=len,
+            )
+            parsed_documents = splitter.split_documents(documents)
+        else:
+            parsed_documents = _format_faq_documents(documents)
 
         logger.info(
             "information_retrieval.faiss_store._create_document_index",
-            len_chunks=len(doc_chunks),
+            len_chunks=len(parsed_documents),
         )
-        if doc_chunks:
-            texts = [chunk.page_content for chunk in doc_chunks]
-            metadatas = [chunk.metadata for chunk in doc_chunks]
+        if parsed_documents:
+            texts = [document.page_content for document in parsed_documents]
+            metadatas = [document.metadata for document in parsed_documents]
             return FAISS.from_texts(texts, embedding, metadatas=metadatas, ids=None)
         else:
             raise ValueError(f"No documents found at '{docs_folder}'.")

rasa/core/information_retrieval/ingestion/faq_parser.py

@@ -0,0 +1,158 @@
+"""Utilities for parsing FAQ-style documents (Q/A pairs) used in extractive search."""
+
+import re
+from collections import defaultdict
+from typing import TYPE_CHECKING, List
+
+import structlog
+
+from rasa.shared.constants import (
+    DOCUMENT_TYPE_FAQ,
+    FAQ_DOCUMENT_ENTRY_SEPARATOR,
+    FAQ_DOCUMENT_LINE_SEPARATOR,
+    FAQ_DOCUMENT_METADATA_ANSWER,
+    FAQ_DOCUMENT_METADATA_TITLE,
+    FAQ_DOCUMENT_METADATA_TYPE,
+    FAQ_INPUT_DATA_ANSWER_LINE_PREFIX,
+    FAQ_INPUT_DATA_QUESTION_LINE_PREFIX,
+)
+
+if TYPE_CHECKING:
+    from langchain.schema import Document
+
+_FAQ_PAIR_PATTERN = re.compile(
+    rf"{re.escape(FAQ_INPUT_DATA_QUESTION_LINE_PREFIX)}\s*"
+    rf"(?P<question>.*?)\s*{FAQ_DOCUMENT_LINE_SEPARATOR}\s*"
+    rf"{re.escape(FAQ_INPUT_DATA_ANSWER_LINE_PREFIX)}\s*"
+    rf"(?P<answer>.*)",
+    re.DOTALL,
+)
+
+
+structlogger = structlog.get_logger()
+
+
+def _format_faq_documents(documents: List["Document"]) -> List["Document"]:
+    """Splits each loaded file into individual FAQs.
+
+    Args:
+        documents: Documents representing whole files containing FAQs.
+
+    Returns:
+        List of Document objects, each containing a separate FAQ.
+
+    Examples:
+        An example of a file containing FAQs:
+
+        Q: Who is Finley?
+        A: Finley is your smart assistant for the FinX App. You can add him to your
+           favorite messenger and tell him what you need help with.
+
+        Q: How does Finley work?
+        A: Finley is powered by the latest chatbot technology leveraging a unique
+           interplay of large language models and secure logic.
+
+    More details in documentation: https://rasa.com/docs/reference/config/policies/extractive-search/
+    """
+    structured_faqs = []
+    from langchain.schema import Document
+
+    for document in documents:
+        chunks = document.page_content.strip().split(FAQ_DOCUMENT_ENTRY_SEPARATOR)
+
+        for chunk in chunks:
+            match = _FAQ_PAIR_PATTERN.match(chunk.strip())
+
+            if not match:
+                structlogger.warning(
+                    "faq_parser.format_faq_documents.invalid_chunk_skipped",
+                    event_info=(
+                        "Chunk does not match expected QA format. "
+                        "Please refer to the documentation: "
+                        "https://rasa.com/docs/reference/config/"
+                        "policies/extractive-search/"
+                    ),
+                    chunk_preview=chunk[:100],
+                )
+                continue
+
+            question = match.group("question").strip()
+            answer = match.group("answer").strip()
+            title = _sanitize_title(question)
+
+            formatted_document = Document(
+                page_content=question,
+                metadata={
+                    FAQ_DOCUMENT_METADATA_TITLE: title,
+                    FAQ_DOCUMENT_METADATA_TYPE: DOCUMENT_TYPE_FAQ,
+                    FAQ_DOCUMENT_METADATA_ANSWER: answer,
+                },
+            )
+
+            structured_faqs.append(formatted_document)
+
+            structlogger.debug(
+                "faq_parser.format_faq_documents.parsed_chunk",
+                event_info="Parsed chunk.",
+                title=title,
+                question=question,
+                answer=answer,
+                parsed_chunk_preview=chunk[:100],
+            )
+
+    structlogger.debug(
+        "faq_parser.format_faq_documents.parsed_chunks",
+        event_info=(
+            f"Retrieved {len(structured_faqs)} FAQ pair(s)"
+            f"from {len(documents)} document(s)."
+        ),
+        num_structured_faqs=len(structured_faqs),
+        num_documents=len(documents),
+    )
+    _check_and_parsed_faq_documents_for_duplicates(structured_faqs)
+    return structured_faqs
+
+
+def _sanitize_title(title: str) -> str:
+    title = title.lower()
+    # Remove all whitespaces with "_"
+    title = re.sub(r"\s+", "_", title)
+    # Remove all non alpha-numeric characters
+    title = re.sub(r"[^\w]", "", title)
+    # Collapse multiple "_"
+    title = re.sub(r"_+", "_", title)
+    # Clean up edges
+    return title.strip("_")
+
+
+def _check_and_parsed_faq_documents_for_duplicates(documents: List["Document"]) -> None:
+    seen_qa_pairs = set()
+    seen_questions: defaultdict = defaultdict(list)
+
+    for doc in documents:
+        question = doc.page_content.strip()
+        answer = doc.metadata.get(FAQ_DOCUMENT_METADATA_ANSWER, "").strip()
+
+        if not question or not answer:
+            continue
+
+        if (question, answer) in seen_qa_pairs:
+            structlogger.warning(
+                "faq_parser.duplicate_qa_pair_found",
+                event_info="Duplicate QA pair found.",
+                question=question,
+                answer_preview=answer,
+            )
+            continue
+
+        if question in seen_questions and seen_questions[question] != answer:
+            structlogger.warning(
+                "faq_parser.inconsistent_answer",
+                event_info="Duplicate question with different answer found.",
+                question=question,
+                previous_answers=seen_questions[question],
+                new_answer=answer,
+            )
+
+        seen_qa_pairs.add((question, answer))
+        seen_questions[question].append(answer)

rasa/core/jobs.py

@@ -1,12 +1,13 @@
 import asyncio
 import logging
+from typing import Optional
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from pytz import UnknownTimeZoneError, utc
 
 import rasa.shared.utils.io
 
-__scheduler = None
+__scheduler: Optional[AsyncIOScheduler] = None
 
 logger = logging.getLogger(__name__)