rasa-pro 3.8.17__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/nlu/featurizers/sparse_featurizer/count_vectors_featurizer.py

@@ -99,7 +99,6 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
         return ["sklearn"]
 
     def _load_count_vect_params(self) -> None:
-
         # Use shared vocabulary between text and all other attributes of Message
         self.use_shared_vocab = self._config["use_shared_vocab"]
 
@@ -340,7 +339,7 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _convert_attribute_tokens_to_texts(
-        attribute_tokens: Dict[Text, List[List[Text]]]
+        attribute_tokens: Dict[Text, List[List[Text]]],
     ) -> Dict[Text, List[Text]]:
         attribute_texts = {}
 
@@ -659,7 +658,6 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
         for message in messages:
             for attribute in self._attributes:
-
                 message_tokens = self._get_processed_message_tokens_by_attribute(
                     message, attribute
                 )
@@ -685,7 +683,7 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _is_any_model_trained(
-        attribute_vocabularies: Dict[Text, Optional[Dict[Text, int]]]
+        attribute_vocabularies: Dict[Text, Optional[Dict[Text, int]]],
     ) -> bool:
         """Check if any model got trained."""
         return any(value is not None for value in attribute_vocabularies.values())

rasa/nlu/featurizers/sparse_featurizer/lexical_syntactic_featurizer.py

@@ -76,9 +76,7 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
 
     # NOTE: "suffix5" of the token "is" will be "is". Hence, when combining multiple
     # prefixes, short words will be represented/encoded repeatedly.
-    _FUNCTION_DICT: Dict[
-        Text, Callable[[Token], Union[Text, bool, None]]
-    ] = {  # noqa: RUF012
+    _FUNCTION_DICT: Dict[Text, Callable[[Token], Union[Text, bool, None]]] = {  # noqa: RUF012
         "low": lambda token: token.text.islower(),
         "title": lambda token: token.text.istitle(),
         "prefix5": lambda token: token.text[:5],
@@ -329,7 +327,6 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         assert len(window_range) == window_size
 
         for anchor in range(len(tokens)):
-
             token_features: Dict[Tuple[int, Text], Text] = {}
 
             for window_position, relative_position in enumerate(window_range):
@@ -341,13 +338,13 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
 
                 token = tokens[absolute_position]
                 for feature_name in self._feature_config[window_position]:
-                    token_features[
-                        (window_position, feature_name)
-                    ] = self._extract_raw_features_from_token(
-                        token=token,
-                        feature_name=feature_name,
-                        token_position=absolute_position,
-                        num_tokens=len(tokens),
+                    token_features[(window_position, feature_name)] = (
+                        self._extract_raw_features_from_token(
+                            token=token,
+                            feature_name=feature_name,
+                            token_position=absolute_position,
+                            num_tokens=len(tokens),
+                        )
                     )
 
             sentence_features.append(token_features)
@@ -356,7 +353,7 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _build_feature_to_index_map(
-        feature_vocabulary: Dict[Tuple[int, Text], Set[Text]]
+        feature_vocabulary: Dict[Tuple[int, Text], Set[Text]],
     ) -> Dict[Tuple[int, Text], Dict[Text, int]]:
         """Creates a nested dictionary for mapping raw features to indices.
 

rasa/nlu/persistor.py

@@ -1,16 +1,18 @@
 import abc
-import logging
+import structlog
 import os
 import shutil
 from typing import Optional, Text, Tuple, TYPE_CHECKING
 
+from rasa.shared.exceptions import RasaException
+
 import rasa.shared.utils.common
 import rasa.utils.common
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 def get_persistor(name: Text) -> Optional["Persistor"]:
@@ -95,7 +97,6 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
-
         ext = ".tar.gz" if include_extension else ""
         return f"{model_name}{ext}"
 
@@ -129,20 +130,36 @@ class AWSPersistor(Persistor):
     def _ensure_bucket_exists(
         self, bucket_name: Text, region_name: Optional[Text] = None
     ) -> None:
-        import boto3
         import botocore
 
-        if not region_name:
-            region_name = boto3.DEFAULT_SESSION.region_name
-
-        bucket_config = {"LocationConstraint": region_name}
         # noinspection PyUnresolvedReferences
         try:
-            self.s3.create_bucket(
-                Bucket=bucket_name, CreateBucketConfiguration=bucket_config
-            )
-        except botocore.exceptions.ClientError:
-            pass  # bucket already exists
+            self.s3.meta.client.head_bucket(Bucket=bucket_name)
+        except botocore.exceptions.ClientError as e:
+            error_code = int(e.response["Error"]["Code"])
+            if error_code == 403:
+                log = (
+                    f"Access to the specified bucket '{bucket_name}' is forbidden. "
+                    "Please make sure you have the necessary "
+                    "permission to access the bucket."
+                )
+                structlogger.error(
+                    "aws_persistor.ensure_bucket_exists.bucket_access_forbidden",
+                    bucket_name=bucket_name,
+                    event_info=log,
+                )
+                raise RasaException(log)
+            elif error_code == 404:
+                log = (
+                    f"The specified bucket '{bucket_name}' does not exist. "
+                    "Please make sure to create the bucket first."
+                )
+                structlogger.error(
+                    "aws_persistor.ensure_bucket_exists.bucket_not_found",
+                    bucket_name=bucket_name,
+                    event_info=log,
+                )
+                raise RasaException(log)
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
@@ -180,10 +197,30 @@ class GCSPersistor(Persistor):
         from google.cloud import exceptions
 
         try:
-            self.storage_client.create_bucket(bucket_name)
-        except exceptions.Conflict:
-            # bucket exists
-            pass
+            self.storage_client.get_bucket(bucket_name)
+        except exceptions.NotFound:
+            log = (
+                f"The specified bucket '{bucket_name}' does not exist. "
+                "Please make sure to create the bucket first."
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.bucket_not_found",
+                bucket_name=bucket_name,
+                event_info=log,
+            )
+            raise RasaException(log)
+        except exceptions.Forbidden:
+            log = (
+                f"Access to the specified bucket '{bucket_name}' is forbidden. "
+                "Please make sure you have the necessary "
+                "permission to access the bucket. "
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.bucket_access_forbidden",
+                bucket_name=bucket_name,
+                event_info=log,
+            )
+            raise RasaException(log)
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to GCS."""
@@ -210,18 +247,23 @@ class AzurePersistor(Persistor):
             account_url=f"https://{azure_account_name}.blob.core.windows.net/",
             credential=azure_account_key,
         )
-
-        self._ensure_container_exists(azure_container)
         self.container_name = azure_container
+        self._ensure_container_exists()
 
-    def _ensure_container_exists(self, container_name: Text) -> None:
-        from azure.core.exceptions import ResourceExistsError
-
-        try:
-            self.blob_service.create_container(container_name)
-        except ResourceExistsError:
-            # no need to create the container, it already exists
+    def _ensure_container_exists(self) -> None:
+        if self._container_client().exists():
             pass
+        else:
+            log = (
+                f"The specified container '{self.container_name}' does not exist."
+                "Please make sure to create the container first."
+            )
+            structlogger.error(
+                "azure_persistor.ensure_container_exists.container_not_found",
+                container_name=self.container_name,
+                event_info=log,
+            )
+            raise RasaException(log)
 
     def _container_client(self) -> "ContainerClient":
         return self.blob_service.get_container_client(self.container_name)

rasa/nlu/selectors/response_selector.py

@@ -430,9 +430,9 @@ class ResponseSelector(DIETClassifier):
         self, message: Message, prediction_dict: Dict[Text, Any], selector_key: Text
     ) -> None:
         message_selector_properties = message.get(RESPONSE_SELECTOR_PROPERTY_NAME, {})
-        message_selector_properties[
-            RESPONSE_SELECTOR_RETRIEVAL_INTENTS
-        ] = self.all_retrieval_intents
+        message_selector_properties[RESPONSE_SELECTOR_RETRIEVAL_INTENTS] = (
+            self.all_retrieval_intents
+        )
         message_selector_properties[selector_key] = prediction_dict
         message.set(
             RESPONSE_SELECTOR_PROPERTY_NAME,
@@ -505,7 +505,6 @@ class ResponseSelector(DIETClassifier):
             been caught earlier and a warning should have been raised.
         """
         for key, responses in self.responses.items():
-
             # First check if the predicted label was the key itself
             search_key = util.template_key_to_intent_response_key(key)
             if search_key == label.get("name"):
@@ -626,7 +625,6 @@ class ResponseSelector(DIETClassifier):
         config: Dict[Text, Any],
         finetune_mode: bool = False,
     ) -> "RasaModel":
-
         predict_data_example = RasaModelData(
             label_key=model_data_example.label_key,
             data={
@@ -723,7 +721,6 @@ class DIET2BOW(DIET):
             logger.debug(f"  {metric} ({name})")
 
     def _update_label_metrics(self, loss: tf.Tensor, acc: tf.Tensor) -> None:
-
         self.response_loss.update_state(loss)
         self.response_acc.update_state(acc)
 
@@ -796,10 +793,10 @@ class DIET2DIET(DIET):
             (self.text_name, self.config),
             (self.label_name, label_config),
         ]:
-            self._tf_layers[
-                f"sequence_layer.{attribute}"
-            ] = rasa_layers.RasaSequenceLayer(
-                attribute, self.data_signature[attribute], config
+            self._tf_layers[f"sequence_layer.{attribute}"] = (
+                rasa_layers.RasaSequenceLayer(
+                    attribute, self.data_signature[attribute], config
+                )
             )
 
         if self.config[MASKED_LM]:

rasa/nlu/test.py

@@ -886,7 +886,6 @@ def evaluate_entities(
             exclude_label=NO_ENTITY,
         )
         if output_directory:
-
             _dump_report(output_directory, f"{extractor}_report.json", report)
 
         if successes:
@@ -1550,7 +1549,6 @@ async def combine_result(
 
 
 def _contains_entity_labels(entity_results: List[EntityEvaluationResult]) -> bool:
-
     for result in entity_results:
         if result.entity_targets or result.entity_predictions:
             return True
@@ -1791,7 +1789,6 @@ async def compare_nlu(
     training_examples_per_run = []
 
     for run in range(runs):
-
         logger.info("Beginning comparison run {}/{}".format(run + 1, runs))
 
         run_path = os.path.join(output, "run_{}".format(run + 1))

rasa/nlu/utils/hugging_face/registry.py

@@ -25,7 +25,7 @@ from transformers import (  # noqa: E402
     RobertaTokenizer,
     CamembertTokenizer,
 )
-from rasa.nlu.utils.hugging_face.transformers_pre_post_processors import (  # noqa: E402, E501
+from rasa.nlu.utils.hugging_face.transformers_pre_post_processors import (  # noqa: E402
     bert_tokens_pre_processor,
     gpt_tokens_pre_processor,
     xlnet_tokens_pre_processor,

rasa/nlu/utils/spacy_utils.py

@@ -195,7 +195,7 @@ class SpacyNLP(GraphComponent):
 
     @staticmethod
     def _filter_training_samples_by_content(
-        indexed_training_samples: List[Tuple[int, Text]]
+        indexed_training_samples: List[Tuple[int, Text]],
     ) -> Tuple[List[Tuple[int, Text]], List[Tuple[int, Text]]]:
         """Separates empty training samples from content bearing ones."""
         docs_to_pipe = list(
@@ -251,7 +251,6 @@ class SpacyNLP(GraphComponent):
     ) -> Dict[Text, List[Any]]:
         attribute_docs = {}
         for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
-
             texts = [
                 self._get_text(e, attribute) for e in training_data.training_examples
             ]
@@ -288,7 +287,6 @@ class SpacyNLP(GraphComponent):
         attribute_docs = self._docs_for_training_data(model.model, training_data)
 
         for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
-
             for idx, example in enumerate(training_data.training_examples):
                 example_attribute_doc = attribute_docs[attribute][idx]
                 if len(example_attribute_doc):

rasa/server.py

@@ -4,6 +4,7 @@ import logging
 import multiprocessing
 import os
 import traceback
+import warnings
 from collections import defaultdict
 from functools import reduce, wraps
 from http import HTTPStatus
@@ -25,6 +26,12 @@ from typing import (
 
 import aiohttp
 import jsonschema
+from sanic import Sanic, response
+from sanic.request import Request
+from sanic.response import HTTPResponse
+from sanic_cors import CORS
+from sanic_jwt import Initialize, exceptions
+
 import rasa
 import rasa.core.utils
 import rasa.nlu.test
@@ -70,11 +77,6 @@ from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.shared.utils.yaml import validate_training_data
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
-from sanic import Sanic, response
-from sanic.request import Request
-from sanic.response import HTTPResponse
-from sanic_cors import CORS
-from sanic_jwt import Initialize, exceptions
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -233,7 +235,6 @@ def requires_auth(
         async def decorated(
             request: Request, *args: Any, **kwargs: Any
         ) -> response.HTTPResponse:
-
             provided = request.args.get("token", None)
 
             # noinspection PyProtectedMember
@@ -518,7 +519,18 @@ def add_root_route(app: Sanic) -> None:
     @app.get("/")
     async def hello(request: Request) -> HTTPResponse:
         """Check if the server is running and responds with the version."""
-        return response.text("Hello from Rasa: " + rasa.__version__)
+        html_content = f"""
+        <html>
+            <body>
+                <p>Hello from Rasa: {rasa.__version__}</p>
+                <a href="./webhooks/inspector/inspect.html">Go to the inspector</a>
+                <script>
+                    window.location.replace("./webhooks/inspector/inspect.html");
+                </script>
+            </body>
+        </html>
+        """
+        return response.html(html_content)
 
 
 def async_if_callback_url(f: Callable[..., Coroutine]) -> Callable:
@@ -647,6 +659,9 @@ def create_app(
     app.config.RESPONSE_TIMEOUT = response_timeout
     configure_cors(app, cors_origins)
 
+    # Reset Sanic warnings filter that allows the triggering of Sanic warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")
+
     # Set up the Sanic-JWT extension
     if jwt_secret and jwt_method:
         # `sanic-jwt` depends on having an available event loop when making the call to

rasa/shared/constants.py

@@ -17,6 +17,7 @@ DOCS_URL_COMPONENTS = DOCS_URL_CONCEPTS + "/components/overview"
 DOCS_URL_GRAPH_COMPONENTS = DOCS_URL_CONCEPTS + "/components/custom-graph-components"
 DOCS_URL_GRAPH_RECIPE = DOCS_URL_CONCEPTS + "/components/graph-recipe"
 DOCS_URL_CATEGORICAL_SLOTS = DOCS_URL_CONCEPTS + "/domain#categorical-slot"
+DOCS_URL_DOMAIN = DOCS_URL_CONCEPTS + "/domain"
 
 # Docs URLs for NLU-based assistants
 DOCS_URL_TRAINING_DATA = DOCS_URL_NLU_BASED + "/training-data-format"
@@ -77,6 +78,8 @@ DEFAULT_LOG_LEVEL_LLM = "DEBUG"
 ENV_LOG_LEVEL_LLM = "LOG_LEVEL_LLM"
 ENV_LOG_LEVEL_LLM_MODULE_NAMES = {
     "LLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
+    "SingleStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
+    "MultiStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "EnterpriseSearchPolicy": "LOG_LEVEL_LLM_ENTERPRISE_SEARCH",
     "IntentlessPolicy": "LOG_LEVEL_LLM_INTENTLESS_POLICY",
     "ContextualResponseRephraser": "LOG_LEVEL_LLM_REPHRASER",
@@ -109,7 +112,7 @@ CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
 REQUIRED_SLOTS_KEY = "required_slots"
 IGNORED_INTENTS = "ignored_intents"
 
-# Constants for default Rasa Open Source project layout
+# Constants for default Rasa Pro project layout
 DEFAULT_ENDPOINTS_PATH = "endpoints.yml"
 DEFAULT_CREDENTIALS_PATH = "credentials.yml"
 DEFAULT_CONFIG_PATH = "config.yml"
@@ -174,8 +177,16 @@ RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY = (
 RASA_PATTERN_CANNOT_HANDLE_PREFIX = "cannot_handle_"
 RASA_PATTERN_CANNOT_HANDLE_DEFAULT = RASA_PATTERN_CANNOT_HANDLE_PREFIX + "default"
 RASA_PATTERN_CANNOT_HANDLE_CHITCHAT = RASA_PATTERN_CANNOT_HANDLE_PREFIX + "chitchat"
+RASA_PATTERN_CANNOT_HANDLE_NOT_SUPPORTED = (
+    RASA_PATTERN_CANNOT_HANDLE_PREFIX + "not_supported"
+)
 RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
     RASA_PATTERN_CANNOT_HANDLE_PREFIX + "invalid_intent"
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
+EMBEDDINGS_CONFIG_KEY = "embeddings"
+MODEL_CONFIG_KEY = "model"
+MODEL_NAME_CONFIG_KEY = "model_name"
+PROMPT_CONFIG_KEY = "prompt"
+PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"

rasa/shared/core/command_payload_reader.py

@@ -0,0 +1,109 @@
+import copy
+import re
+from typing import List, Optional
+
+import structlog
+
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.shared.core.domain import Domain
+from rasa.shared.nlu.constants import COMMANDS, SET_SLOT_COMMAND, TEXT
+from rasa.shared.nlu.training_data.message import Message
+
+structlogger = structlog.get_logger()
+
+SET_SLOTS_PATTERN = r"(?P<slot_name>[^(),=]+)=(?P<slot_value>[^(),]+)"
+MAX_NUMBER_OF_SLOTS = 10
+
+
+class CommandPayloadReader:
+    @staticmethod
+    def unpack_regex_message(
+        message: Message,
+        domain: Optional[Domain] = None,
+        entity_extractor_name: Optional[
+            str
+        ] = SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
+    ) -> Message:
+        """Extracts commands from user text and adds them to the message."""
+        user_text = message.get(TEXT).strip()
+
+        # prevent ReDos attacks by placing a limit on the number of slots
+        if CommandPayloadReader.is_above_slot_limit(user_text):
+            return message
+
+        matches = CommandPayloadReader.find_matches(user_text)
+        if not matches:
+            structlogger.warning(
+                "message.parsing.failed", user_text=copy.deepcopy(user_text)
+            )
+            return message
+
+        return CommandPayloadReader.extract_commands_from_pattern_matches(
+            message, matches, domain, entity_extractor_name
+        )
+
+    @staticmethod
+    def find_matches(user_text: str) -> List[re.Match]:
+        return re.findall(SET_SLOTS_PATTERN, user_text)
+
+    @staticmethod
+    def extract_commands_from_pattern_matches(
+        message: Message,
+        matches: List[re.Match],
+        domain: Optional[Domain] = None,
+        entity_extractor_name: Optional[
+            str
+        ] = SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
+    ) -> Message:
+        """Extract attributes from the matches and validate them via the domain."""
+        commands = []
+
+        for match in matches:
+            slot_name = match[0].strip()
+            slot_value = match[1].strip()
+
+            domain_slot_names = [slot.name for slot in domain.slots] if domain else []
+
+            if domain and slot_name not in domain_slot_names:
+                structlogger.warning(
+                    "slot.not.found",
+                    slot_name=slot_name,
+                )
+                return message
+
+            slot_value = (
+                slot_value
+                if slot_value.lower() not in {"none", "null", "undefined"}
+                else None
+            )
+
+            # Create new SetSlot commands from the extracted attributes.
+            commands.append(
+                {
+                    "command": SET_SLOT_COMMAND,
+                    "name": slot_name,
+                    "value": slot_value,
+                    "extractor": entity_extractor_name,
+                }
+            )
+
+            structlogger.debug(
+                "slot.set.command.added",
+                slot_name=slot_name,
+            )
+
+        # set the command(s) on the Message object
+        message.set(COMMANDS, commands, add_to_output=True)
+        return message
+
+    @staticmethod
+    def is_above_slot_limit(user_text: str) -> bool:
+        """Prevent ReDoS attacks by limiting the number of slots."""
+        if user_text.count("=") > MAX_NUMBER_OF_SLOTS:
+            structlogger.warning(
+                "too.many.slots",
+                user_text=copy.deepcopy(user_text),
+                slot_limit=10,
+            )
+            return True
+        return False

rasa/shared/core/constants.py

@@ -85,6 +85,7 @@ LOOP_INTERRUPTED = "is_interrupted"
 LOOP_REJECTED = "rejected"
 TRIGGER_MESSAGE = "trigger_message"
 FOLLOWUP_ACTION = "followup_action"
+ACTIVE_FLOW = "active_flow"
 
 # start of special user message section
 EXTERNAL_MESSAGE_PREFIX = "EXTERNAL: "
@@ -130,6 +131,7 @@ class SlotMappingType(Enum):
     FROM_INTENT = "from_intent"
     FROM_TRIGGER_INTENT = "from_trigger_intent"
     FROM_TEXT = "from_text"
+    FROM_LLM = "from_llm"
     CUSTOM = "custom"
 
     def __str__(self) -> str:
@@ -137,11 +139,8 @@ class SlotMappingType(Enum):
         return self.value
 
     def is_predefined_type(self) -> bool:
-        """Returns True iff the mapping type is predefined.
-
-        That is, to evaluate the mapping no custom action execution is needed.
-        """
-        return self != SlotMappingType.CUSTOM
+        """Returns True if the mapping type is NLU-predefined."""
+        return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
 
 
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)