rasa-pro 3.9.18__py3-none-any.whl

rasa/core/http_interpreter.py

@@ -0,0 +1,89 @@
+import aiohttp
+
+import copy
+import logging
+import structlog
+
+from typing import Text, Dict, Any, Optional
+
+from rasa.core import constants
+from rasa.core.channels import UserMessage
+from rasa.shared.nlu.constants import INTENT_NAME_KEY
+from rasa.utils.endpoints import EndpointConfig
+
+logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
+
+
+class RasaNLUHttpInterpreter:
+    """Allows for an HTTP endpoint to be used to parse messages."""
+
+    def __init__(self, endpoint_config: Optional[EndpointConfig] = None) -> None:
+        """Initializes a `RasaNLUHttpInterpreter`."""
+        self.session = aiohttp.ClientSession()
+        if endpoint_config:
+            self.endpoint_config = endpoint_config
+        else:
+            self.endpoint_config = EndpointConfig(constants.DEFAULT_SERVER_URL)
+
+    async def parse(self, message: UserMessage) -> Dict[Text, Any]:
+        """Parse a text message.
+
+        Return a default value if the parsing of the text failed.
+        """
+        default_return = {
+            "intent": {INTENT_NAME_KEY: "", "confidence": 0.0},
+            "entities": [],
+            "text": "",
+        }
+
+        result = await self._rasa_http_parse(message.text, message.sender_id)
+        return result if result is not None else default_return
+
+    async def _rasa_http_parse(
+        self, text: Text, message_id: Optional[Text] = None
+    ) -> Optional[Dict[Text, Any]]:
+        """Send a text message to a running rasa NLU http server.
+
+        Return `None` on failure.
+        """
+        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
+
+        params = {
+            "token": self.endpoint_config.token,
+            "text": text,
+            "message_id": message_id,
+        }
+
+        if self.endpoint_config.url.endswith("/"):
+            url = self.endpoint_config.url + "model/parse"
+        else:
+            url = self.endpoint_config.url + "/model/parse"
+
+        # noinspection PyBroadException
+        try:
+            async with self.session.post(url, json=params) as resp:
+                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),
+                    )
+                    return None
+        except Exception:  # 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),
+            )
+            return None

rasa/core/information_retrieval/__init__.py

@@ -0,0 +1,7 @@
+from rasa.core.information_retrieval.information_retrieval import (  # noqa: F401
+    InformationRetrieval,
+    SearchResult,
+    SearchResultList,
+    InformationRetrievalException,
+    create_from_endpoint_config,
+)

rasa/core/information_retrieval/faiss.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Text, Any, Dict
+
+import structlog
+from langchain.document_loaders import DirectoryLoader, TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores.faiss import FAISS
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+from rasa.utils.ml_utils import persist_faiss_vector_store
+
+if TYPE_CHECKING:
+    from langchain.schema import Document
+    from langchain.schema.embeddings import Embeddings
+
+logger = structlog.get_logger()
+
+
+class FAISS_Store(InformationRetrieval):
+    """FAISS Store implementation."""
+
+    def __init__(
+        self,
+        embeddings: "Embeddings",
+        index_path: str,
+        docs_folder: Optional[str],
+        create_index: Optional[bool] = False,
+    ):
+        """Initializes the FAISS Store."""
+        self.chunk_size = 1000
+        self.chunk_overlap = 20
+
+        path = Path(index_path) / "documents_faiss"
+        if create_index:
+            logger.info(
+                "information_retrieval.faiss_store.create_index", path=path.absolute()
+            )
+            self.index = self._create_document_index(docs_folder, embeddings)
+            self._persist(path)
+        else:
+            logger.info(
+                "information_retrieval.faiss_store.load_index", path=path.absolute()
+            )
+            self.index = FAISS.load_local(str(path), embeddings)
+
+    @staticmethod
+    def load_documents(docs_folder: str) -> List["Document"]:
+        """Loads documents from a given folder.
+
+        Args:
+            docs_folder: The folder containing the documents.
+
+        Returns:
+            the list of documents
+        """
+        logger.info(
+            "information_retrieval.faiss_store.load_documents",
+            docs_folder=Path(docs_folder).absolute(),
+        )
+        loader = DirectoryLoader(
+            docs_folder, glob="**/*.txt", loader_cls=TextLoader, show_progress=True
+        )
+
+        return loader.load()
+
+    def _create_document_index(
+        self, docs_folder: Optional[str], embedding: "Embeddings"
+    ) -> FAISS:
+        """Creates a document index from the documents in the given folder.
+
+        Args:
+            docs_folder: The folder containing the documents.
+            embedding: The embedding to use.
+
+        Returns:
+            The document index.
+        """
+        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)
+
+        logger.info(
+            "information_retrieval.faiss_store._create_document_index",
+            len_chunks=len(doc_chunks),
+        )
+        if doc_chunks:
+            texts = [chunk.page_content for chunk in doc_chunks]
+            metadatas = [chunk.metadata for chunk in doc_chunks]
+            return FAISS.from_texts(texts, embedding, metadatas=metadatas, ids=None)
+        else:
+            raise ValueError(f"No documents found at '{docs_folder}'.")
+
+    def _persist(self, path: Path) -> None:
+        persist_faiss_vector_store(path, self.index)
+
+    def connect(self, config: EndpointConfig) -> None:
+        """Faiss does not need to connect to a server."""
+        pass
+
+    async def search(
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+    ) -> SearchResultList:
+        logger.debug("information_retrieval.faiss_store.search", query=query)
+        try:
+            documents = await self.index.as_retriever().aget_relevant_documents(query)
+        except Exception as exc:
+            raise InformationRetrievalException from exc
+
+        return SearchResultList.from_document_list(documents)

rasa/core/information_retrieval/information_retrieval.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Text, Any, Optional
+
+import structlog
+
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+import importlib
+
+if TYPE_CHECKING:
+    from langchain.schema import Document
+    from langchain.schema.embeddings import Embeddings
+
+
+logger = structlog.get_logger()
+
+
+@dataclass
+class SearchResult:
+    text: str
+    metadata: dict
+    score: Optional[float] = None
+
+    @classmethod
+    def from_document(cls, document: Document) -> "SearchResult":
+        """Construct a SearchResult object from Langchain Document object."""
+        return cls(text=document.page_content, metadata=document.metadata)
+
+
+@dataclass
+class SearchResultList:
+    results: List[SearchResult]
+    metadata: dict
+
+    @classmethod
+    def from_document_list(cls, documents: List["Document"]) -> "SearchResultList":
+        """
+        Convert a list of Langchain Documents to a SearchResultList object.
+
+        Args:
+            documents: List of Langchain Documents.
+
+        Returns:
+            SearchResultList object.
+        """
+        return cls(
+            results=[SearchResult.from_document(doc) for doc in documents],
+            metadata={"total_results": len(documents)},
+        )
+
+
+class InformationRetrievalException(RasaException):
+    """Base class for exceptions raised by InformationRetrieval operations."""
+
+    def __init__(self) -> None:
+        self.base_message = "An error occurred while searching for documents: "
+
+    def __str__(self) -> str:
+        return self.base_message + f"{self.__cause__}"
+
+
+class InformationRetrieval:
+    """Base class for any InformationRetrieval implementation."""
+
+    def __init__(self, embeddings: "Embeddings") -> None:
+        self.embeddings = embeddings
+
+    def connect(
+        self,
+        config: EndpointConfig,
+    ) -> None:
+        """Connect to the InformationRetrieval system."""
+        raise NotImplementedError(
+            "InformationRetrieval must implement the `connect` method."
+        )
+
+    async def search(
+        self,
+        query: Text,
+        tracker_state: dict[str, Any],
+        threshold: float = 0.0,
+    ) -> SearchResultList:
+        """Search for a document in the InformationRetrieval system."""
+        raise NotImplementedError(
+            "InformationRetrieval must implement the `search` method."
+        )
+
+
+def create_from_endpoint_config(
+    config_type: Text,
+    embeddings: "Embeddings",
+) -> InformationRetrieval:
+    """Instantiate a vector store based on its configuration."""
+    logger.debug(
+        "information_retrieval.create_from_endpoint_config", config_type=config_type
+    )
+    if config_type == "milvus":
+        from rasa.core.information_retrieval.milvus import Milvus_Store
+
+        return Milvus_Store(embeddings=embeddings)
+    elif config_type == "qdrant":
+        from rasa.core.information_retrieval.qdrant import Qdrant_Store
+
+        return Qdrant_Store(embeddings=embeddings)
+    else:
+        # Import the module dynamically
+        try:
+            module_name, class_name = config_type.rsplit(".", 1)
+            module = importlib.import_module(module_name)
+        except ValueError:
+            logger.error(
+                "information_retrieval.create_from_endpoint_config.invalid_config",
+                config_type=config_type,
+            )
+            raise ValueError(
+                f"Invalid configuration for vector store: '{config_type}'. "
+                f"Expected a module path and a class name separated by a dot."
+            )
+        except ModuleNotFoundError:
+            logger.error(
+                "information_retrieval.create_from_endpoint_config.unknown_type",
+                config_type=config_type,
+            )
+            raise ImportError(f"Cannot retrieve class from path {config_type}.")
+
+        external_class = getattr(module, class_name)
+        return external_class(embeddings=embeddings)

rasa/core/information_retrieval/milvus.py

@@ -0,0 +1,52 @@
+from typing import Text, Any, Dict
+
+import structlog
+from langchain.vectorstores.milvus import Milvus
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+
+logger = structlog.get_logger()
+
+
+class Milvus_Store(InformationRetrieval):
+    """Milvus Store implementation."""
+
+    def connect(self, config: EndpointConfig) -> None:
+        """Connect to the Milvus system."""
+        params = config.kwargs
+        self.client = Milvus(
+            self.embeddings,
+            connection_args={
+                "host": str(params.get("host")),
+                "port": str(params.get("port")),
+                "user": str(params.get("user")),
+                "password": str(params.get("password")),
+            },
+            collection_name=str(params.get("collection")),
+        )
+
+    async def search(
+        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.
+
+        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=4)
+        except Exception as exc:
+            raise InformationRetrievalException from exc
+
+        filtered_hits = [doc for doc, score in hits if score >= threshold]
+        return SearchResultList.from_document_list(filtered_hits)

rasa/core/information_retrieval/qdrant.py

@@ -0,0 +1,95 @@
+from typing import Text, Any, Dict
+
+import structlog
+from langchain.vectorstores.qdrant import Qdrant
+from pydantic import ValidationError
+from qdrant_client import QdrantClient
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+
+logger = structlog.get_logger()
+
+
+class PayloadNotFoundException(InformationRetrievalException):
+    """Exception raised for errors in missing payloads."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__()
+
+    def __str__(self) -> str:
+        return self.base_message + self.message + f"{self.__cause__}"
+
+
+class QdrantInformationRetrievalException(InformationRetrievalException):
+    """Exception raised for errors in the Qdrant vector store."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__()
+
+    def __str__(self) -> str:
+        return self.base_message + self.message + f"{self.__cause__}"
+
+
+class Qdrant_Store(InformationRetrieval):
+    def connect(
+        self,
+        config: EndpointConfig,
+    ) -> None:
+        """Connect to the Qdrant system."""
+        params = config.kwargs
+        self.client = Qdrant(
+            client=QdrantClient(
+                location=params.get("location"),
+                url=params.get("url"),
+                port=int(params.get("port", 6333)),
+                grpc_port=int(params.get("grpc_port", 6334)),
+                prefer_grpc=bool(params.get("prefer_grpc", False)),
+                https=bool(params.get("https")),
+                api_key=params.get("api_key"),
+                prefix=params.get("prefix"),
+                timeout=int(params.get("timeout", 5)),
+                host=params.get("host"),
+                path=params.get("path"),
+            ),
+            collection_name=str(params.get("collection")),
+            embeddings=self.embeddings,
+            content_payload_key=params.get("content_payload_key", "text"),
+            metadata_payload_key=params.get("metadata_payload_key", "metadata"),
+        )
+
+    async def search(
+        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.
+
+        Returns:
+        A list of documents that match the query.
+        """
+        logger.debug("information_retrieval.qdrant_store.search", query=query)
+        try:
+            hits = await self.client.asimilarity_search(
+                query, k=4, score_threshold=threshold
+            )
+        except ValidationError as e:
+            raise PayloadNotFoundException(
+                "Payload not found in the Qdrant response. Please make sure "
+                "the `content_payload_key`and `metadata_payload_key` are correct in "
+                f"the Qdrant configuration. Error: {e}"
+                ""
+            ) from e
+        except Exception as e:
+            raise QdrantInformationRetrievalException(
+                f"Failed to search the Qdrant vector store. Encountered error: {e}"
+            ) from e
+        return SearchResultList.from_document_list(hits)

rasa/core/jobs.py

@@ -0,0 +1,63 @@
+import asyncio
+import logging
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from pytz import UnknownTimeZoneError, utc
+import rasa.shared.utils.io
+
+__scheduler = None
+
+logger = logging.getLogger(__name__)
+
+
+async def scheduler() -> AsyncIOScheduler:
+    """Thread global scheduler to handle all recurring tasks.
+
+    If no scheduler exists yet, this will instantiate one.
+    """
+    global __scheduler
+
+    if not __scheduler:
+        try:
+            __scheduler = AsyncIOScheduler(event_loop=asyncio.get_event_loop())
+            __scheduler.start()
+            return __scheduler
+        except UnknownTimeZoneError:
+            rasa.shared.utils.io.raise_warning(
+                "apscheduler could not find a timezone and is "
+                "defaulting to utc. This is probably because "
+                "your system timezone is not set. "
+                'Set it with e.g. echo "Europe/Berlin" > '
+                "/etc/timezone"
+            )
+            __scheduler = AsyncIOScheduler(
+                event_loop=asyncio.get_event_loop(), timezone=utc
+            )
+            __scheduler.start()
+            return __scheduler
+    else:
+        # scheduler already created, make sure it is running on
+        # the correct loop
+        # noinspection PyProtectedMember
+        if not __scheduler._eventloop == asyncio.get_event_loop():
+            raise RuntimeError(
+                "Detected inconsistent loop usage. "
+                "Trying to schedule a task on a new event "
+                "loop, but scheduler was created with a "
+                "different event loop. Make sure there "
+                "is only one event loop in use and that the "
+                "scheduler is running on that one."
+            )
+        return __scheduler
+
+
+def kill_scheduler() -> None:
+    """Terminate the scheduler if started.
+
+    Another call to `scheduler` will create a new scheduler.
+    """
+    global __scheduler
+
+    if __scheduler:
+        __scheduler.shutdown()
+        __scheduler = None

rasa/core/lock.py

@@ -0,0 +1,139 @@
+import json
+import logging
+from collections import deque
+
+import time
+from typing import Text, Optional, Union, Deque, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+NO_TICKET_ISSUED = -1  # index of latest issued ticket if no tickets exist
+
+
+class Ticket:
+    def __init__(self, number: int, expires: float) -> None:
+        self.number = number
+        self.expires = expires
+
+    def has_expired(self) -> bool:
+        return time.time() > self.expires
+
+    def as_dict(self) -> Dict[Text, Any]:
+        return dict(number=self.number, expires=self.expires)
+
+    def dumps(self) -> Text:
+        """Return json dump of `Ticket` as dictionary."""
+        return json.dumps(self.as_dict())
+
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Union[int, float]]) -> "Ticket":
+        """Creates `Ticket` from dictionary."""
+        return cls(number=data["number"], expires=data["expires"])
+
+    def __repr__(self) -> Text:
+        return f"Ticket(number: {self.number}, expires: {self.expires})"
+
+
+class TicketLock:
+    """Locking mechanism that issues tickets managing access to conversation IDs.
+
+    Tickets are issued in the order in which they are requested. A detailed
+    explanation of the ticket lock algorithm can be found at
+    http://pages.cs.wisc.edu/~remzi/OSTEP/threads-locks.pdf#page=13
+    """
+
+    def __init__(
+        self, conversation_id: Text, tickets: Optional[Deque[Ticket]] = None
+    ) -> None:
+        self.conversation_id = conversation_id
+        self.tickets = tickets or deque()
+
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Any]) -> "TicketLock":
+        """Create `TicketLock` from dictionary."""
+        tickets = [Ticket.from_dict(json.loads(d)) for d in data.get("tickets", [])]
+        return cls(data.get("conversation_id"), deque(tickets))
+
+    def dumps(self) -> Text:
+        """Return json dump of `TicketLock`."""
+        tickets = [ticket.dumps() for ticket in self.tickets]
+        return json.dumps(dict(conversation_id=self.conversation_id, tickets=tickets))
+
+    def is_locked(self, ticket_number: int) -> bool:
+        """Return whether `ticket_number` is locked.
+
+        Returns:
+             True if `now_serving` is not equal to `ticket`.
+        """
+        return self.now_serving != ticket_number
+
+    def issue_ticket(self, lifetime: float) -> int:
+        """Issue a new ticket and return its number."""
+        self.remove_expired_tickets()
+        number = self.last_issued + 1
+        ticket = Ticket(number, time.time() + lifetime)
+        self.tickets.append(ticket)
+
+        return number
+
+    def remove_expired_tickets(self) -> None:
+        """Remove expired tickets."""
+        # iterate over copy of self.tickets so we can remove items
+        for ticket in list(self.tickets):
+            if ticket.has_expired():
+                self.tickets.remove(ticket)
+
+    @property
+    def last_issued(self) -> int:
+        """Return number of the ticket that was last added.
+
+        Returns:
+             Number of `Ticket` that was last added. `NO_TICKET_ISSUED` if no
+             tickets exist.
+        """
+        ticket_number = self._ticket_number_for(-1)
+
+        return ticket_number if ticket_number is not None else NO_TICKET_ISSUED
+
+    @property
+    def now_serving(self) -> Optional[int]:
+        """Get number of the ticket to be served next.
+
+        Returns:
+             Number of `Ticket` that is served next. 0 if no `Ticket` exists.
+        """
+        return self._ticket_number_for(0) or 0
+
+    def _ticket_number_for(self, ticket_index: int) -> Optional[int]:
+        """Get ticket number for `ticket_index`.
+
+        Returns:
+             Ticket number for `Ticket` with index `ticket_index`. None if there are no
+             tickets, or if `ticket_index` is out of bounds of `self.tickets`.
+        """
+        self.remove_expired_tickets()
+
+        try:
+            return self.tickets[ticket_index].number
+        except IndexError:
+            return None
+
+    def _ticket_for_ticket_number(self, ticket_number: int) -> Optional[Ticket]:
+        """Return ticket for `ticket_number`."""
+        self.remove_expired_tickets()
+
+        return next((t for t in self.tickets if t.number == ticket_number), None)
+
+    def is_someone_waiting(self) -> bool:
+        """Return whether someone is waiting for the lock to become available.
+
+        Returns:
+             True if the `self.tickets` queue has length greater than 0.
+        """
+        return len(self.tickets) > 0
+
+    def remove_ticket_for(self, ticket_number: int) -> None:
+        """Remove `Ticket` for `ticket_number."""
+        ticket = self._ticket_for_ticket_number(ticket_number)
+        if ticket:
+            self.tickets.remove(ticket)