rasa-pro 3.13.0.dev2__py3-none-any.whl → 3.13.0.dev5__py3-none-any.whl

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/information_retrieval/faiss.py

@@ -31,12 +31,10 @@ class FAISS_Store(InformationRetrieval):
         index_path: str,
         docs_folder: Optional[str],
         create_index: Optional[bool] = False,
-        use_llm: bool = False,
     ):
         """Initializes the FAISS Store."""
         self.chunk_size = 1000
         self.chunk_overlap = 20
-        self.use_llm = use_llm
 
         path = Path(index_path) / "documents_faiss"
         if create_index:
@@ -73,57 +71,6 @@ class FAISS_Store(InformationRetrieval):
 
         return loader.load()
 
-    def _format_faqs(self, docs: List["Document"]) -> List["Document"]:
-        """Splits each loaded file into individual FAQs.
-
-        Args:
-            docs: 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 doc in docs:
-            faq_chunks = doc.page_content.strip().split("\n\n")
-
-            for chunk in faq_chunks:
-                lines = chunk.strip().split("\n")
-                if len(lines) < 2:
-                    continue  # Skip if something unexpected
-
-                question_line = lines[0].strip()
-                answer_line = lines[1].strip()
-
-                question = question_line.replace("Q: ", "").strip()
-                answer = answer_line.replace("A: ", "").strip()
-
-                doc_obj = Document(
-                    page_content=question,
-                    metadata={
-                        "title": question.lower().replace(" ", "_")[:-1],
-                        "type": "faq",
-                        "answer": answer,
-                    },
-                )
-
-                structured_faqs.append(doc_obj)
-        return structured_faqs
-
     def _create_document_index(
         self, docs_folder: Optional[str], embedding: "Embeddings"
     ) -> FAISS:
@@ -140,15 +87,12 @@ class FAISS_Store(InformationRetrieval):
             raise ValueError("parameter `docs_folder` needs to be specified")
 
         docs = self.load_documents(docs_folder)
-        if self.use_llm:
-            splitter = RecursiveCharacterTextSplitter(
-                chunk_size=self.chunk_size,
-                chunk_overlap=self.chunk_overlap,
-                length_function=len,
-            )
-            doc_chunks = splitter.split_documents(docs)
-        else:
-            doc_chunks = self._format_faqs(docs)
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=self.chunk_size,
+            chunk_overlap=self.chunk_overlap,
+            length_function=len,
+        )
+        doc_chunks = splitter.split_documents(docs)
 
         logger.info(
             "information_retrieval.faiss_store._create_document_index",
@@ -169,15 +113,10 @@ class FAISS_Store(InformationRetrieval):
         pass
 
     async def search(
-        self,
-        query: Text,
-        tracker_state: Dict[str, Any],
-        threshold: float = 0.0,
-        k: int = 1,
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
     ) -> SearchResultList:
         logger.debug("information_retrieval.faiss_store.search", query=query)
         try:
-            # TODO: make use of k
             documents = await self.index.as_retriever().ainvoke(query)
         except Exception as exc:
             raise InformationRetrievalException from exc

rasa/core/information_retrieval/information_retrieval.py

@@ -36,19 +36,6 @@ class SearchResult:
         """Construct a SearchResult object from Langchain Document object."""
         return cls(text=document.page_content, metadata=document.metadata)
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "SearchResult":
-        """Construct a SearchResult object from a JSON object."""
-        return cls(text=data["text"], metadata=data["metadata"], score=data["score"])
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the SearchResult object to a dictionary."""
-        return {
-            "text": self.text,
-            "metadata": self.metadata,
-            "score": self.score,
-        }
-
 
 @dataclass
 class SearchResultList:
@@ -57,7 +44,8 @@ class SearchResultList:
 
     @classmethod
     def from_document_list(cls, documents: List["Document"]) -> "SearchResultList":
-        """Convert a list of Langchain Documents to a SearchResultList object.
+        """
+        Convert a list of Langchain Documents to a SearchResultList object.
 
         Args:
             documents: List of Langchain Documents.
@@ -70,31 +58,6 @@ class SearchResultList:
             metadata={"total_results": len(documents)},
         )
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "SearchResultList":
-        """Convert a JSON object to a SearchResultList object.
-
-        Args:
-            data: JSON object.
-
-        Returns:
-            SearchResultList object.
-        """
-        if not data:
-            return cls(results=[], metadata={})
-
-        return cls(
-            results=[SearchResult.from_dict(result) for result in data["results"]],
-            metadata=data["metadata"],
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the SearchResultList object to a dictionary."""
-        return {
-            "results": [result.to_dict() for result in self.results],
-            "metadata": self.metadata,
-        }
-
 
 class InformationRetrievalException(RasaException):
     """Base class for exceptions raised by InformationRetrieval operations."""
@@ -126,7 +89,6 @@ class InformationRetrieval:
         query: Text,
         tracker_state: dict[str, Any],
         threshold: float = 0.0,
-        k: int = 1,
     ) -> SearchResultList:
         """Search for a document in the InformationRetrieval system."""
         raise NotImplementedError(

rasa/core/information_retrieval/milvus.py

@@ -31,25 +31,20 @@ class Milvus_Store(InformationRetrieval):
         )
 
     async def search(
-        self,
-        query: Text,
-        tracker_state: Dict[str, Any],
-        threshold: float = 0.0,
-        k: int = 1,
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
     ) -> SearchResultList:
         """Search for documents in the Milvus store.
 
         Args:
             query: The query to search for.
             threshold: minimum similarity score to consider a document a match.
-            k: number of results to return.
 
         Returns:
         A list of documents that match the query.
         """
         logger.debug("information_retrieval.milvus_store.search", query=query)
         try:
-            hits = await self.client.asimilarity_search_with_score(query, k=k)
+            hits = await self.client.asimilarity_search_with_score(query, k=4)
         except Exception as exc:
             raise InformationRetrievalException from exc
 

rasa/core/information_retrieval/qdrant.py

@@ -66,18 +66,13 @@ class Qdrant_Store(InformationRetrieval):
         )
 
     async def search(
-        self,
-        query: Text,
-        tracker_state: Dict[str, Any],
-        threshold: float = 0.0,
-        k: int = 1,
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
     ) -> SearchResultList:
         """Search for a document in the Qdrant vector store.
 
         Args:
             query: The query to search for.
             threshold: minimum similarity score to consider a document a match.
-            k: number of results to return.
 
         Returns:
         A list of documents that match the query.
@@ -85,7 +80,7 @@ class Qdrant_Store(InformationRetrieval):
         logger.debug("information_retrieval.qdrant_store.search", query=query)
         try:
             hits = await self.client.asimilarity_search(
-                query, k=k, score_threshold=threshold
+                query, k=4, score_threshold=threshold
             )
         except ValidationError as e:
             raise PayloadNotFoundException(

rasa/core/lock_store.py

@@ -2,18 +2,27 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
 import os
 from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Dict, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+
+import structlog
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    Field,
+    NonNegativeInt,
+    model_validator,
+)
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME
 from rasa.core.lock import TicketLock
 from rasa.shared.exceptions import ConnectionException, RasaException
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 
 def _get_lock_lifetime() -> int:
@@ -76,7 +85,10 @@ class LockStore:
 
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             ticket = lock.issue_ticket(lock_lifetime)
@@ -109,7 +121,10 @@ class LockStore:
     async def _acquire_lock(
         self, conversation_id: Text, ticket: int, wait_time_in_seconds: float
     ) -> TicketLock:
-        logger.debug(f"Acquiring lock for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store._acquiring_lock_for_conversation",
+            event_info=f"Acquiring lock for conversation '{conversation_id}'.",
+        )
         while True:
             # fetch lock in every iteration because lock might no longer exist
             lock = self.get_lock(conversation_id)
@@ -120,16 +135,22 @@ class LockStore:
 
             # acquire lock if it isn't locked
             if not lock.is_locked(ticket):
-                logger.debug(f"Acquired lock for conversation '{conversation_id}'.")
+                structlogger.debug(
+                    "lock_store._acquired_lock_for_conversation",
+                    event_info=f"Acquired lock for conversation '{conversation_id}'.",
+                )
                 return lock
 
             items_before_this = ticket - (lock.now_serving or 0)
 
-            logger.debug(
-                f"Failed to acquire lock for conversation ID '{conversation_id}' "
-                f"because {items_before_this} other item(s) for this "
-                f"conversation ID have to be finished processing first. "
-                f"Retrying in {wait_time_in_seconds} seconds ..."
+            structlogger.debug(
+                "lock_store._retrying_lock_acquisition",
+                event_info=(
+                    f"Failed to acquire lock for conversation ID '{conversation_id}' "
+                    f"because {items_before_this} other item(s) for this "
+                    f"conversation ID have to be finished processing first. "
+                    f"Retrying in {wait_time_in_seconds} seconds ..."
+                ),
             )
 
             # sleep and update lock
@@ -186,9 +207,99 @@ class LockStore:
     @staticmethod
     def _log_deletion(conversation_id: Text, deletion_successful: bool) -> None:
         if deletion_successful:
-            logger.debug(f"Deleted lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._deleted_lock_for_conversation",
+                event_info=f"Deleted lock for conversation '{conversation_id}'.",
+            )
         else:
-            logger.debug(f"Could not delete lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._failed_to_delete_lock_for_conversation",
+                event_info=(
+                    f"Could not delete lock for conversation '{conversation_id}'."
+                ),
+            )
+
+
+class RedisLockStoreConfig(BaseModel):
+    host: Union[AnyUrl, Literal["localhost"]] = Field(
+        default="localhost", description="The host of the redis server."
+    )
+    port: NonNegativeInt = Field(
+        default=6379, ge=0, le=65535, description="The port of the redis server."
+    )
+    db: NonNegativeInt = Field(
+        default=0,
+        ge=0,
+        description="The name of the database within Redis "
+        "which should be used by Rasa",
+    )
+    username: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    use_ssl: bool = Field(
+        default=False,
+        serialization_alias="ssl",
+        description="True if SSL should be used for the connection to Redis.",
+    )
+    ssl_certfile: Optional[str] = Field(
+        default=None,
+        description="Path to the SSL certificate file.",
+    )
+    ssl_keyfile: Optional[str] = Field(
+        default=None, description="Path to the SSL private key file."
+    )
+    ssl_ca_certs: Optional[str] = Field(
+        default=None, description="Path to the SSL CA certificate file."
+    )
+    key_prefix: Optional[str] = Field(
+        default=None,
+        description="Prefix to prepend to all keys "
+        "used by the lock store. Must be alphanumeric.",
+    )
+    socket_timeout: float = Field(
+        default=DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        description="Timeout in seconds after which an exception "
+        "will be raised in case Redis doesn't respond "
+        "within `socket_timeout` seconds.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_url_and_host_properties(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if bool(data.get("url", None)) and bool(data.get("host", None)):
+                raise RasaException(
+                    "You cannot specify both 'url' and 'host' in the Redis lock store "
+                    "configuration. Please use only one of them."
+                )
+
+            if data.get("url", None):
+                raise_deprecation_warning(
+                    "The 'url' property in the redis lock store "
+                    "configuration is deprecated. Please use 'host' instead."
+                )
+                data["host"] = data.pop("url")
+        return data
+
+    @model_validator(mode="after")
+    def verify_username_password(self) -> RedisLockStoreConfig:
+        if bool(self.username) ^ bool(self.password):
+            raise ValueError(
+                f"Expected username and password. "
+                f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
+                f"password: {'<has value>' if self.password else '<N/A>'}"
+            )
+        return self
+
+    def to_strict_redis(self) -> Dict[str, Any]:
+        return self.model_dump(by_alias=True, exclude={"key_prefix"})
 
 
 class RedisLockStore(LockStore):
@@ -196,57 +307,28 @@ class RedisLockStore(LockStore):
 
     def __init__(
         self,
-        host: Text = "localhost",
-        port: int = 6379,
-        db: int = 1,
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        use_ssl: bool = False,
-        ssl_certfile: Optional[Text] = None,
-        ssl_keyfile: Optional[Text] = None,
-        ssl_ca_certs: Optional[Text] = None,
-        key_prefix: Optional[Text] = None,
-        socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        config: RedisLockStoreConfig = RedisLockStoreConfig(),
     ) -> None:
         """Create a lock store which uses Redis for persistence.
 
         Args:
-            host: The host of the redis server.
-            port: The port of the redis server.
-            db: The name of the database within Redis which should be used by Rasa
-                Open Source.
-            username: The username which should be used for authentication with the
-                Redis database.
-            password: The password which should be used for authentication with the
-                Redis database.
-            use_ssl: `True` if SSL should be used for the connection to Redis.
-            ssl_certfile: Path to the SSL certificate file.
-            ssl_keyfile: Path to the SSL private key file.
-            ssl_ca_certs: Path to the SSL CA certificate file.
-            key_prefix: prefix to prepend to all keys used by the lock store. Must be
-                alphanumeric.
-            socket_timeout: Timeout in seconds after which an exception will be raised
-                in case Redis doesn't respond within `socket_timeout` seconds.
+            config: Redis lock store configuration.
         """
         import redis
 
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
-        )
+        self.config = config
+        self.red = redis.StrictRedis(**self.config.to_strict_redis())
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
-        if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
-            self._set_key_prefix(key_prefix)
+        if self.config.key_prefix:
+            structlogger.debug(
+                "redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=(
+                    f"Setting non-default "
+                    f"redis key prefix: '{self.config.key_prefix}'.",
+                ),
+            )
+            self._set_key_prefix(self.config.key_prefix)
 
         super().__init__()
 
@@ -254,9 +336,13 @@ class RedisLockStore(LockStore):
         if isinstance(key_prefix, str) and key_prefix.isalnum():
             self.key_prefix = key_prefix + ":" + DEFAULT_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(
+                "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 get_lock(self, conversation_id: Text) -> Optional[TicketLock]:
@@ -313,7 +399,9 @@ def _create_from_endpoint_config(
 
         lock_store: LockStore = InMemoryLockStore()
     elif endpoint_config.type == "redis":
-        lock_store = RedisLockStore(host=endpoint_config.url, **endpoint_config.kwargs)
+        config = RedisLockStoreConfig.model_validate(endpoint_config.to_dict())
+
+        lock_store = RedisLockStore(config)
     elif endpoint_config.type == "concurrent_redis":
         from rasa.core.concurrent_lock_store import ConcurrentRedisLockStore
 
@@ -321,7 +409,10 @@ def _create_from_endpoint_config(
     else:
         lock_store = _load_from_module_name_in_endpoint_config(endpoint_config)
 
-    logger.debug(f"Connected to lock store '{lock_store.__class__.__name__}'.")
+    structlogger.debug(
+        "lock_store._create_from_endpoint_config.lock_store_connected",
+        event_info=f"Connected to lock store '{lock_store.__class__.__name__}'.",
+    )
 
     return lock_store
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -27,6 +27,7 @@ from rasa.shared.nlu.constants import (
     PROMPTS,
 )
 from rasa.shared.providers.llm.llm_response import LLMResponse, measure_llm_latency
+from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_GENERATE_MODEL_NAME,
@@ -105,6 +106,8 @@ class ContextualResponseRephraser(
         self.prompt_template = get_prompt_template(
             self.nlg_endpoint.kwargs.get(PROMPT_CONFIG_KEY),
             DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+            log_source_component=ContextualResponseRephraser.__name__,
+            log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
         )
         self.rephrase_all = self.nlg_endpoint.kwargs.get(
             "rephrase_all", DEFAULT_REPHRASE_ALL