rasa-pro 3.9.18__py3-none-any.whl

rasa/core/concurrent_lock_store.py

@@ -0,0 +1,210 @@
+import json
+import logging
+import time
+from collections import deque
+from typing import Deque, Optional, Text
+
+from rasa.core.lock import Ticket, TicketLock
+from rasa.core.lock_store import (
+    DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+    LOCK_LIFETIME,
+    LockError,
+    LockStore,
+)
+from rasa.utils.endpoints import EndpointConfig
+
+DEFAULT_REDIS_DB = 1
+
+DEFAULT_PORT = 6379
+
+DEFAULT_HOSTNAME = "localhost"
+
+logger = logging.getLogger(__name__)
+
+LAST_ISSUED_TICKET_NUMBER_SUFFIX = "last_issued_ticket_number"
+
+DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX = "concurrent_lock:"
+
+
+class ConcurrentTicketLock(TicketLock):
+    def concurrent_issue_ticket(self, lifetime: float, ticket_number: int) -> int:
+        """Issue a new ticket and return its number.
+
+        Args:
+            lifetime: The length of time after which the ticket expires.
+            ticket_number: Integer representing the ticket number.
+
+        Returns:
+            ticket_number integer.
+
+        """
+        ticket = Ticket(ticket_number, time.time() + lifetime)
+        self.tickets.append(ticket)
+
+        return ticket_number
+
+
+class ConcurrentRedisLockStore(LockStore):
+    """Concurrent implementation of a Redis store for ticket locks."""
+
+    def __init__(
+        self,
+        endpoint_config: EndpointConfig,
+    ) -> None:
+        """Create a lock store which uses Redis for persistence.
+
+        Args:
+            endpoint_config: The endpointConfig defined the lock store.
+
+            Can contain the following properties:
+            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.
+        """
+        import redis
+
+        host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
+        port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
+        db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
+        username = endpoint_config.kwargs.get("username")
+        password = endpoint_config.kwargs.get("password")
+        use_ssl = bool(endpoint_config.kwargs.get("use_ssl", False))
+        ssl_certfile = endpoint_config.kwargs.get("ssl_certfile")
+        ssl_keyfile = endpoint_config.kwargs.get("ssl_keyfile")
+        ssl_ca_certs = endpoint_config.kwargs.get("ssl_ca_certs")
+        key_prefix = endpoint_config.kwargs.get("key_prefix")
+        socket_timeout = endpoint_config.kwargs.get(
+            "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
+        )
+
+        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.key_prefix = DEFAULT_CONCURRENT_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)
+
+        super().__init__()
+
+    def _set_key_prefix(self, key_prefix: Text) -> None:
+        if isinstance(key_prefix, str) and key_prefix.isalnum():
+            self.key_prefix = (
+                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."
+            )
+
+    def issue_ticket(
+        self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
+    ) -> int:
+        """Issue new ticket for a conversation.
+
+        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}'.")
+        try:
+            lock = self.get_or_create_lock(conversation_id)
+            lock.remove_expired_tickets()
+            ticket_number = self.increment_ticket_number(lock)
+            ticket = lock.concurrent_issue_ticket(lock_lifetime, ticket_number)  # type: ignore[attr-defined]
+            self.save_lock(lock)
+
+            return ticket
+        except Exception as e:
+            raise LockError(f"Error while acquiring lock. Error:\n{e}")
+
+    def get_lock(self, conversation_id: Text) -> Optional[ConcurrentTicketLock]:
+        """Retrieves lock (see parent docstring for more information)."""
+        tickets: Deque[Ticket] = deque()
+
+        pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
+        redis_keys = self.red.keys(pattern)
+
+        for key in redis_keys:
+            serialised_ticket = self.red.get(key)
+            if serialised_ticket:
+                ticket = Ticket.from_dict(json.loads(serialised_ticket))
+                tickets.appendleft(ticket)
+
+        tickets = deque(sorted(tickets, key=lambda x: x.number))
+
+        return ConcurrentTicketLock(conversation_id, tickets)
+
+    def delete_lock(self, conversation_id: Text) -> None:
+        """Deletes lock for conversation ID."""
+        pattern = self.key_prefix + conversation_id + ":*"
+        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}'."
+            )
+            return None
+
+        deletion_successful = self.red.delete(*redis_keys)
+        if deletion_successful == 0:
+            self._log_deletion(conversation_id, False)
+        else:
+            self._log_deletion(conversation_id, True)
+
+    def save_lock(self, lock: TicketLock) -> None:
+        """Commit individual tickets and last issued ticket number to storage."""
+        last_issued_ticket = lock.tickets[-1]
+        serialised_ticket = last_issued_ticket.dumps()
+        key = (
+            self.key_prefix
+            + lock.conversation_id
+            + ":"
+            + str(last_issued_ticket.number)
+        )
+        self.red.set(
+            name=key, value=serialised_ticket, ex=int(last_issued_ticket.expires)
+        )
+
+    def increment_ticket_number(self, lock: TicketLock) -> int:
+        """Uses Redis atomic transaction to increment ticket number."""
+        last_issued_key = (
+            self.key_prefix
+            + lock.conversation_id
+            + ":"
+            + LAST_ISSUED_TICKET_NUMBER_SUFFIX
+        )
+
+        return self.red.incr(name=last_issued_key)
+
+    def finish_serving(self, conversation_id: Text, ticket_number: int) -> None:
+        """Finish serving ticket with `ticket_number` for `conversation_id`.
+
+        Removes ticket from storage.
+        """
+        ticket_key = self.key_prefix + conversation_id + ":" + str(ticket_number)
+        self.red.delete(ticket_key)

rasa/core/constants.py

@@ -0,0 +1,107 @@
+DEFAULT_SERVER_PORT = 5005
+
+DEFAULT_SERVER_INTERFACE = "0.0.0.0"
+
+DEFAULT_SERVER_FORMAT = "{}://localhost:{}"
+
+DEFAULT_SERVER_URL = DEFAULT_SERVER_FORMAT.format("http", DEFAULT_SERVER_PORT)
+
+DEFAULT_INTERACTIVE_SERVER_URL = "{}://localhost:{}"
+
+DEFAULT_NLU_FALLBACK_THRESHOLD = 0.3
+
+DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD = 0.1
+
+DEFAULT_CORE_FALLBACK_THRESHOLD = 0.3
+
+DEFAULT_MAX_HISTORY = None  # Core policy history is unbounded by default.
+
+DEFAULT_RESPONSE_TIMEOUT = 60 * 60  # 1 hour
+
+DEFAULT_REQUEST_TIMEOUT = 60 * 5  # 5 minutes
+
+DEFAULT_STREAM_READING_TIMEOUT = 10  # in seconds
+
+DEFAULT_LOCK_LIFETIME = 60  # in seconds
+
+DEFAULT_KEEP_ALIVE_TIMEOUT = 120  # in seconds
+
+BEARER_TOKEN_PREFIX = "Bearer "
+
+# The lowest priority is intended to be used by machine learning policies.
+DEFAULT_POLICY_PRIORITY = 1
+
+# The priority of intent-prediction policies.
+# This should be below all rule based policies but higher than ML
+# based policies. This enables a loop inside ensemble where if none
+# of the rule based policies predict an action and intent prediction
+# policy predicts one, its prediction is chosen by the ensemble and
+# then the ML based policies are again run to get the prediction for
+# an actual action. To prevent an infinite loop, intent prediction
+# policies only predict an action if the last event in
+# the tracker is of type `UserUttered`. Hence, they make at most
+# one action prediction in each conversation turn. This allows other
+# policies to predict a winning action prediction.
+UNLIKELY_INTENT_POLICY_PRIORITY = DEFAULT_POLICY_PRIORITY + 1
+
+# The priority intended to be used by memoization policies.
+# It is higher than default to prioritize training stories.
+MEMOIZATION_POLICY_PRIORITY = UNLIKELY_INTENT_POLICY_PRIORITY + 1
+
+# The priority of the `RulePolicy` is higher than all other policies since
+# rule execution takes precedence over training stories or predicted actions.
+RULE_POLICY_PRIORITY = MEMOIZATION_POLICY_PRIORITY + 1
+
+# chat policy priority
+CHAT_POLICY_PRIORITY = RULE_POLICY_PRIORITY + 1
+
+# search policy priority
+SEARCH_POLICY_PRIORITY = CHAT_POLICY_PRIORITY + 1
+
+# flow policy priority
+FLOW_POLICY_PRIORITY = SEARCH_POLICY_PRIORITY + 1
+
+
+DIALOGUE = "dialogue"
+
+# RabbitMQ message property header added to events published using `rasa export`
+RASA_EXPORT_PROCESS_ID_HEADER_NAME = "rasa-export-process-id"
+
+# Name of the environment variable defining the PostgreSQL schema to access. See
+# https://www.postgresql.org/docs/9.1/ddl-schemas.html for more details.
+POSTGRESQL_SCHEMA = "POSTGRESQL_SCHEMA"
+
+# Names of the environment variables defining PostgreSQL pool size and max overflow
+POSTGRESQL_POOL_SIZE = "SQL_POOL_SIZE"
+POSTGRESQL_MAX_OVERFLOW = "SQL_MAX_OVERFLOW"
+
+# File names for testing
+CONFUSION_MATRIX_STORIES_FILE = "story_confusion_matrix.png"
+REPORT_STORIES_FILE = "story_report.json"
+FAILED_STORIES_FILE = "failed_test_stories.yml"
+SUCCESSFUL_STORIES_FILE = "successful_test_stories.yml"
+STORIES_WITH_WARNINGS_FILE = "stories_with_warnings.yml"
+
+POLICY_PRIORITY = "priority"
+POLICY_FEATURIZER = "featurizer"
+POLICY_MAX_HISTORY = "max_history"
+
+DEFAULT_PROTOCOL = "UDP"
+DEFAULT_SYSLOG_HOST = "localhost"
+DEFAULT_SYSLOG_PORT = 514
+
+COMPRESS_ACTION_SERVER_REQUEST_ENV_NAME = "COMPRESS_ACTION_SERVER_REQUEST"
+DEFAULT_COMPRESS_ACTION_SERVER_REQUEST = False
+
+# uses python like string formatting for the interpolation of templates
+RASA_FORMAT_TEMPLATE_ENGINE = "format"
+
+# uses jinja for the interpolation of templates
+JINJA2_TEMPLATE_ENGINE = "jinja"
+
+# default engine used if no engine is specified in the response
+DEFAULT_TEMPLATE_ENGINE = RASA_FORMAT_TEMPLATE_ENGINE
+
+# configuration parameter used to specify the template engine to use
+# for a response
+TEMPLATE_ENGINE_CONFIG_KEY = "template"

rasa/core/evaluation/marker.py

@@ -0,0 +1,267 @@
+from rasa.shared.core.domain import Domain
+from typing import Optional, Text, List
+from rasa.core.evaluation.marker_base import (
+    OperatorMarker,
+    ConditionMarker,
+    MarkerRegistry,
+    Marker,
+)
+from rasa.shared.core.events import ActionExecuted, SlotSet, UserUttered, Event
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@MarkerRegistry.configurable_marker
+class AndMarker(OperatorMarker):
+    """Checks that all sub-markers apply."""
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "and"
+
+    @staticmethod
+    def negated_tag() -> Text:
+        """Returns the tag to be used in a config file for the negated version."""
+        return "at_least_one_not"
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        return all(marker.history[-1] for marker in self.sub_markers)
+
+
+@MarkerRegistry.configurable_marker
+class OrMarker(OperatorMarker):
+    """Checks that at least one sub-marker applies."""
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "or"
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        return any(marker.history[-1] for marker in self.sub_markers)
+
+
+@MarkerRegistry.configurable_marker
+class NotMarker(OperatorMarker):
+    """Checks that at least one sub-marker applies."""
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "not"
+
+    @staticmethod
+    def expected_number_of_sub_markers() -> Optional[int]:
+        """Returns the expected number of sub-markers (if there is any)."""
+        return 1
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        return not self.sub_markers[0].history[-1]
+
+
+@MarkerRegistry.configurable_marker
+class SequenceMarker(OperatorMarker):
+    """Checks that all sub-markers apply consecutively in the specified order.
+
+    The sequence marker application follows two rules:
+    (1) Given a sequence of sub-markers `m_0, m_1,...,m_n`, the sequence marker applies
+        at the `i`-th event if all sub-markers successively applied to some previous
+        events and the last sub-marker applies at the current `i`-th events.
+    (2) If the sequence marker applies at the `i`-th event, then for it's next
+        application the events up to the `i`-th event will be ignored.
+
+    """
+
+    def __init__(
+        self, markers: List[Marker], negated: bool = False, name: Optional[Text] = None
+    ) -> None:
+        """Instantiate a new sequence marker.
+
+        Args:
+            markers: the sub-markers listed in the expected order
+            negated: whether this marker should be negated (i.e. a negated marker
+                applies if and only if the non-negated marker does not apply)
+            name: a custom name that can be used to replace the default string
+                conversion of this marker
+        """
+        super().__init__(markers=markers, negated=negated, name=name)
+        self._progress: int = 0
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "seq"
+
+    def _to_str_with(self, tag: Text) -> Text:
+        sub_markers_str = " -> ".join(str(marker) for marker in self.sub_markers)
+        return f"{tag}({sub_markers_str})"
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        # Remember that all the sub-markers have been updated before this tracker.
+        # Hence, whether the sub-markers apply to the current `event` is stored in the
+        # last item of their history. Hence, to check if we made some progress in
+        # identifying a sequence, we can simply check:
+        if self.sub_markers[self._progress].history[-1]:
+            self._progress += 1
+        # If we were able to apply every sub-marker once, we reset our progress:
+        if self._progress == len(self.sub_markers):
+            self._progress = 0
+            return True
+        return False
+
+
+@MarkerRegistry.configurable_marker
+class OccurrenceMarker(OperatorMarker):
+    """Checks that all sub-markers applied at least once in history.
+
+    It doesn't matter if the sub markers stop applying later in history. If they
+    applied at least once they will always evaluate to `True`.
+    """
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "at_least_once"
+
+    @staticmethod
+    def negated_tag() -> Optional[Text]:
+        """Returns the tag to be used in a config file for the negated version."""
+        return "never"
+
+    @staticmethod
+    def expected_number_of_sub_markers() -> Optional[int]:
+        """Returns the expected number of sub-markers (if there is any)."""
+        return 1
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        occurred_before = False
+
+        if self.history:
+            occurred_before = self.history[-1]
+            if self.negated:
+                occurred_before = not occurred_before
+
+        return occurred_before or self.sub_markers[0].history[-1]
+
+    def relevant_events(self) -> List[int]:
+        """Only return index of first match (see parent class for full docstring)."""
+        try:
+            return [self.history.index(True)]
+        except ValueError:
+            return []
+
+
+@MarkerRegistry.configurable_marker
+class ActionExecutedMarker(ConditionMarker):
+    """Checks whether an action is executed at the current step."""
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "action"
+
+    @staticmethod
+    def negated_tag() -> Optional[Text]:
+        """Returns the tag to be used in a config file for the negated version."""
+        return "not_action"
+
+    def validate_against_domain(self, domain: Domain) -> bool:
+        """Checks that this marker (and its children) refer to entries in the domain.
+
+        Args:
+            domain: The domain to check against
+        """
+        valid = self.text in domain.action_names_or_texts
+
+        if not valid:
+            logger.error(
+                f"Referenced action '{self.text}' does not exist in the domain"
+            )
+
+        return valid
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        return isinstance(event, ActionExecuted) and event.action_name == self.text
+
+
+@MarkerRegistry.configurable_marker
+class IntentDetectedMarker(ConditionMarker):
+    """Checks whether an intent is expressed at the current step.
+
+    More precisely it applies at an event if this event is a `UserUttered` event
+    where either (1) the retrieval intent or (2) just the intent coincides with
+    the specified text.
+    """
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "intent"
+
+    @staticmethod
+    def negated_tag() -> Optional[Text]:
+        """Returns the tag to be used in a config file for the negated version."""
+        return "not_intent"
+
+    def validate_against_domain(self, domain: Domain) -> bool:
+        """Checks that this marker (and its children) refer to entries in the domain.
+
+        Args:
+            domain: The domain to check against
+        """
+        valid = self.text in domain.intent_properties
+
+        if not valid:
+            logger.error(
+                f"Referenced intent '{self.text}' does not exist in the domain"
+            )
+
+        return valid
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        return isinstance(event, UserUttered) and self.text in [
+            event.intent_name,
+            event.full_retrieval_intent_name,
+        ]
+
+
+@MarkerRegistry.configurable_marker
+class SlotSetMarker(ConditionMarker):
+    """Checks whether a slot is set at the current step.
+
+    The actual `SlotSet` event might have happened at an earlier step.
+    """
+
+    @staticmethod
+    def positive_tag() -> Text:
+        """Returns the tag to be used in a config file."""
+        return "slot_was_set"
+
+    @staticmethod
+    def negated_tag() -> Optional[Text]:
+        """Returns the tag to be used in a config file for the negated version."""
+        return "slot_was_not_set"
+
+    def validate_against_domain(self, domain: Domain) -> bool:
+        """Checks that this marker (and its children) refer to entries in the domain.
+
+        Args:
+            domain: The domain to check against.
+        """
+        valid = any(self.text == slot.name for slot in domain.slots)
+
+        if not valid:
+            logger.error(f"Referenced slot '{self.text}' does not exist in the domain")
+
+        return valid
+
+    def _non_negated_version_applies_at(self, event: Event) -> bool:
+        if isinstance(event, SlotSet) and event.key == self.text:
+            # slot is set if and only if it's value is not `None`
+            return event.value is not None
+        if self.history:
+            was_set = self.history[-1] if not self.negated else not self.history[-1]
+            return was_set
+        return False