rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/channels/webexteams.py

@@ -0,0 +1,134 @@
+import logging
+from sanic import Blueprint, response
+from sanic.request import Request
+from typing import Text, Optional, Dict, Any, Callable, Awaitable
+
+from sanic.response import HTTPResponse
+from webexteamssdk import WebexTeamsAPI, Webhook
+
+from rasa.core.channels.channel import InputChannel
+from rasa.core.channels.channel import UserMessage, OutputChannel
+
+logger = logging.getLogger(__name__)
+
+
+class WebexTeamsBot(OutputChannel):
+    """A Cisco WebexTeams communication channel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "webexteams"
+
+    def __init__(self, access_token: Optional[Text], room: Optional[Text]) -> None:
+        self.room = room
+        self.api = WebexTeamsAPI(access_token)
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        recipient = self.room or recipient_id
+        for message_part in text.strip().split("\n\n"):
+            self.api.messages.create(roomId=recipient, text=message_part)
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        recipient = self.room or recipient_id
+        return self.api.messages.create(roomId=recipient, files=[image])
+
+    async def send_custom_json(
+        self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        json_message.setdefault("roomId", recipient_id)
+        return self.api.messages.create(**json_message)
+
+
+class WebexTeamsInput(InputChannel):
+    """WebexTeams input channel. Based on the HTTPInputChannel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "webexteams"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        return cls(credentials.get("access_token"), credentials.get("room"))
+
+    def __init__(self, access_token: Text, room: Optional[Text] = None) -> None:
+        """Create a Cisco Webex Teams input channel.
+
+        Needs a couple of settings to properly authenticate and validate
+        messages. Details here https://developer.webex.com/authentication.html
+
+        Args:
+            access_token: Cisco WebexTeams bot access token.
+            room: the string identifier for a room to which the bot posts
+        """
+        self.token = access_token
+        self.room = room
+        self.api = WebexTeamsAPI(access_token)
+
+    async def process_message(
+        self,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        text: Optional[Text],
+        sender_id: Optional[Text],
+        metadata: Optional[Dict],
+    ) -> Any:
+        try:
+            out_channel = self.get_output_channel()
+            user_msg = UserMessage(
+                text,
+                out_channel,
+                sender_id,
+                input_channel=self.name(),
+                metadata=metadata,
+            )
+            await on_new_message(user_msg)
+        except Exception as e:
+            logger.error(f"Exception when trying to handle message.{e}")
+            logger.error(str(e), exc_info=True)
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        webexteams_webhook = Blueprint("webexteams_webhook", __name__)
+
+        @webexteams_webhook.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @webexteams_webhook.route("/webhook", methods=["POST"])
+        async def webhook(request: Request) -> HTTPResponse:
+            """Respond to inbound webhook HTTP POST from Webex Teams."""
+            logger.debug("Received webex webhook call")
+            # Get the POST data sent from Webex Teams
+            json_data = request.json
+
+            # Create a Webhook object from the JSON data
+            webhook_obj = Webhook(json_data)
+            # Get the message details
+            message = self.api.messages.get(webhook_obj.data.id)
+
+            # This is a VERY IMPORTANT loop prevention control step.
+            # If you respond to all messages...  You will respond to the
+            # messages that the bot posts and thereby create a loop
+            me = self.api.people.me()
+            if message.personId == me.id:
+                # Message was sent by me (bot); do not respond.
+                return response.text("OK")
+
+            else:
+                metadata = self.get_metadata(request)
+                await self.process_message(
+                    on_new_message, message.text, message.roomId, metadata
+                )
+                return response.text("")
+
+        return webexteams_webhook
+
+    def get_output_channel(self) -> OutputChannel:
+        return WebexTeamsBot(self.token, self.room)

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,112 @@
+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"
+
+# metadata keys for bot utterance events
+UTTER_SOURCE_METADATA_KEY = "utter_source"
+DOMAIN_GROUND_TRUTH_METADATA_KEY = "domain_ground_truth"
+ACTIVE_FLOW_METADATA_KEY = "active_flow"
+STEP_ID_METADATA_KEY = "step_id"