rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/shared/utils/llm.py

@@ -1,7 +1,9 @@
+import importlib.resources
 import json
 from copy import deepcopy
 from functools import wraps
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -9,7 +11,6 @@ from typing import (
     Text,
     Type,
     TypeVar,
-    TYPE_CHECKING,
     Union,
     cast,
 )
@@ -19,19 +20,19 @@ import structlog
 import rasa.shared.utils.io
 from rasa.core.utils import AvailableEndpoints
 from rasa.shared.constants import (
-    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
-    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
-    PROVIDER_CONFIG_KEY,
+    DEFAULT_PROMPT_PACKAGE_NAME,
+    MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODELS_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
     ROUTER_CONFIG_KEY,
 )
 from rasa.shared.core.events import BotUttered, UserUttered
-from rasa.shared.core.slots import Slot, BooleanSlot, CategoricalSlot
-from rasa.shared.engine.caching import (
-    get_local_cache_location,
-)
+from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, Slot
+from rasa.shared.engine.caching import get_local_cache_location
 from rasa.shared.exceptions import (
     FileIOException,
     FileNotFoundException,
@@ -50,13 +51,13 @@ from rasa.shared.providers._configs.self_hosted_llm_client_config import (
 from rasa.shared.providers.embedding.embedding_client import EmbeddingClient
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.providers.mappings import (
-    get_llm_client_from_provider,
     AZURE_OPENAI_PROVIDER,
+    HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     OPENAI_PROVIDER,
     SELF_HOSTED_PROVIDER,
-    get_embedding_client_from_provider,
-    HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     get_client_config_class_from_provider,
+    get_embedding_client_from_provider,
+    get_llm_client_from_provider,
 )
 
 if TYPE_CHECKING:
@@ -355,13 +356,13 @@ def _combine_single_model_configs(
         )
         # Checks for deprecated keys, resolves aliases and returns a valid config.
         # This is done to ensure that the custom config is valid.
-        return client_config_clazz.from_dict(custom_config).to_dict()
+        return client_config_clazz.from_dict(deepcopy(custom_config)).to_dict()
 
     # If the provider is the same in both configs
     # OR provider is not specified in the custom config
     # perform MERGE by overriding the default config keys and values
     # with custom config keys and values.
-    merged_config = {**default_config.copy(), **custom_config.copy()}
+    merged_config = {**deepcopy(default_config), **deepcopy(custom_config)}
     # Check for deprecated keys, resolve aliases and return a valid config.
     # This is done to ensure that the merged config is valid.
     default_config_clazz = get_client_config_class_from_provider(
@@ -512,7 +513,7 @@ def llm_client_factory(
     Returns:
         Instantiated LLM based on the configuration.
     """
-    config = combine_custom_and_default_config(custom_config, default_config)
+    config = combine_custom_and_default_config(deepcopy(custom_config), default_config)
 
     ensure_cache()
 
@@ -641,7 +642,7 @@ def embedder_client_factory(
     Returns:
         Instantiated Embedder based on the configuration.
     """
-    config = combine_custom_and_default_config(custom_config, default_config)
+    config = combine_custom_and_default_config(deepcopy(custom_config), default_config)
 
     ensure_cache()
 
@@ -666,15 +667,96 @@ def get_prompt_template(
     """
     try:
         if jinja_file_path is not None:
-            return rasa.shared.utils.io.read_file(jinja_file_path)
+            prompt_template = rasa.shared.utils.io.read_file(jinja_file_path)
+            structlogger.info(
+                "utils.llm.get_prompt_template.custom_prompt_template_read_successfull",
+                event_info=(
+                    f"Custom prompt template read successfully from "
+                    f"`{jinja_file_path}`."
+                ),
+                prompt_file_path=jinja_file_path,
+            )
+            return prompt_template
     except (FileIOException, FileNotFoundException):
         structlogger.warning(
-            "Failed to read custom prompt template. Using default template instead.",
-            jinja_file_path=jinja_file_path,
+            "utils.llm.get_prompt_template.failed_to_read_custom_prompt_template",
+            event_info=(
+                "Failed to read custom prompt template. Using default template instead."
+            ),
         )
     return default_prompt_template
 
 
+def get_default_prompt_template_based_on_model(
+    llm_config: Dict[str, Any],
+    model_prompt_mapping: Dict[str, Any],
+    default_prompt_path: str,
+    fallback_prompt_path: str,
+) -> Text:
+    """Returns the default prompt template based on the model name.
+
+    Args:
+        llm_config: The model config.
+        model_prompt_mapping: The mapping of model name to prompt template.
+        default_prompt_path: The default prompt path of the component.
+        fallback_prompt_path: The fallback prompt path for all other models
+            that do not have a mapping in the model_prompt_mapping.
+
+    Returns:
+        The default prompt template.
+    """
+    _llm_config = deepcopy(llm_config)
+    if MODELS_CONFIG_KEY in _llm_config:
+        _llm_config = _llm_config[MODELS_CONFIG_KEY][0]
+    provider = _llm_config.get(PROVIDER_CONFIG_KEY)
+    model = _llm_config.get(MODEL_CONFIG_KEY)
+    if not model:
+        # If the model is not defined, we default to the default prompt template.
+        structlogger.info(
+            "utils.llm.get_default_prompt_template_based_on_model.using_default_prompt_template",
+            event_info=(
+                f"Model not defined in the config. Default prompt template read from"
+                f" - `{default_prompt_path}`."
+            ),
+            default_prompt_path=default_prompt_path,
+        )
+        return importlib.resources.read_text(
+            DEFAULT_PROMPT_PACKAGE_NAME, default_prompt_path
+        )
+
+    model_name = model if provider and provider in model else f"{provider}/{model}"
+    if prompt_file_path := model_prompt_mapping.get(model_name):
+        # If the model is found in the mapping, we use the model-specific prompt
+        # template.
+        structlogger.info(
+            "utils.llm.get_default_prompt_template_based_on_model.using_model_specific_prompt_template",
+            event_info=(
+                f"Using model-specific default prompt template. Default prompt "
+                f"template read from - `{prompt_file_path}`."
+            ),
+            default_prompt_path=prompt_file_path,
+            model_name=model_name,
+        )
+        return importlib.resources.read_text(
+            DEFAULT_PROMPT_PACKAGE_NAME, prompt_file_path
+        )
+
+    # If the model is not found in the mapping, we default to the fallback prompt
+    # template.
+    structlogger.info(
+        "utils.llm.get_default_prompt_template_based_on_model.using_fallback_prompt_template",
+        event_info=(
+            f"Model not found in the model prompt mapping. Fallback prompt template "
+            f"read from - `{fallback_prompt_path}`."
+        ),
+        fallback_prompt_path=fallback_prompt_path,
+        model_name=model_name,
+    )
+    return importlib.resources.read_text(
+        DEFAULT_PROMPT_PACKAGE_NAME, fallback_prompt_path
+    )
+
+
 def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     """Get the allowed values for a slot."""
     if isinstance(slot, BooleanSlot):

rasa/shared/utils/pykwalify_extensions.py

@@ -4,10 +4,15 @@ loaded as an extension of the pykwalify library:
 https://pykwalify.readthedocs.io/en/latest/extensions.html#extensions
 """
 
-from typing import Any, List, Dict, Text, Union
+from typing import Any, Dict, List, Text, Union
 
 from pykwalify.errors import SchemaError
 
+from rasa.shared.utils.constants import (
+    RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
+)
+from rasa.utils.beta import ensure_beta_feature_is_enabled
+
 
 def require_response_keys(
     responses: List[Dict[Text, Any]], _: Dict, __: Text
@@ -24,4 +29,23 @@ def require_response_keys(
                 "null 'text' value in response."
             )
 
+        conditions = response.get("condition", [])
+        if isinstance(conditions, str):
+            ensure_beta_feature_is_enabled(
+                "predicates in response conditions",
+                RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
+            )
+            continue
+
+        for condition in conditions:
+            if not isinstance(condition, dict):
+                return SchemaError("Condition must be a dictionary.")
+            if not all(key in condition for key in ("type", "name", "value")):
+                return SchemaError(
+                    "Condition must have 'type', 'name', and 'value' keys."
+                )
+
+            if condition.get("type") != "slot":
+                return SchemaError("Condition type must be of type `slot`.")
+
     return True

rasa/shared/utils/schemas/domain.yml

@@ -78,7 +78,6 @@ mapping:
           mappings:
            type: "seq"
            required: False
-           allowempty: False
            sequence:
               - type: "map"
                 allowempty: True
@@ -99,6 +98,11 @@ mapping:
                     type: "any"
                   action:
                     type: "str"
+                  run_action_every_turn:
+                    type: "str"
+                  coexistence_system:
+                    type: "str"
+                    enum: ["NLU", "CALM", "SHARED"]
                   conditions:
                     type: "seq"
                     sequence:
@@ -112,6 +116,27 @@ mapping:
                           active_flow:
                             type: "str"
                             nullable: True
+          validation:
+            type: map
+            required: false
+            mapping:
+              rejections:
+                type: seq
+                required: true
+                sequence:
+                  - type: map
+                    mapping:
+                      if:
+                        type: str
+                        required: true
+                      utter:
+                        type: str
+                        required: true
+              refill_utter:
+                type: str
+                required: false
+                nullable: false
+
   forms:
     type: "map"
     required: False

rasa/shared/utils/schemas/events.py

@@ -161,7 +161,7 @@ FLOW_CANCELLED = {
     }
 }
 DIALOGUE_STACK_UPDATED = {
-    "properties": {"event": {"const": "stack"}, "update": {"type": "array"}}
+    "properties": {"event": {"const": "stack"}, "update": {"type": "string"}}
 }
 ROUTING_SESSION_ENDED = {"properties": {"event": {"const": "routing_session_ended"}}}
 

rasa/shared/utils/yaml.py

@@ -1,57 +1,57 @@
-from contextlib import contextmanager
 import datetime
 import io
 import logging
 import os
 import re
 from collections import OrderedDict
-from dataclasses import dataclass
-from dataclasses import field
+from contextlib import contextmanager
+from dataclasses import dataclass, field
 from functools import lru_cache
 from io import StringIO
 from pathlib import Path
-from typing import Any, Generator, List, Optional, Tuple, Dict, Callable, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Union
 
 import jsonschema
 from importlib_resources import files
 from packaging import version
 from pykwalify.core import Core
 from pykwalify.errors import SchemaError
+from ruamel import yaml as yaml
+from ruamel.yaml import YAML, RoundTripRepresenter, YAMLError
+from ruamel.yaml.comments import CommentedMap, CommentedSeq
+from ruamel.yaml.constructor import BaseConstructor, DuplicateKeyError, ScalarNode
+from ruamel.yaml.loader import SafeLoader
+
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
     ASSERTIONS_SCHEMA_FILE,
-    MODEL_CONFIG_SCHEMA_FILE,
     CONFIG_SCHEMA_FILE,
     DOCS_URL_TRAINING_DATA,
-    PACKAGE_NAME,
     LATEST_TRAINING_DATA_FORMAT_VERSION,
-    SCHEMA_EXTENSIONS_FILE,
+    MODEL_CONFIG_SCHEMA_FILE,
+    PACKAGE_NAME,
     RESPONSES_SCHEMA_FILE,
+    SCHEMA_EXTENSIONS_FILE,
     SENSITIVE_DATA,
 )
 from rasa.shared.exceptions import (
+    FileNotFoundException,
+    RasaException,
+    SchemaValidationError,
     YamlException,
     YamlSyntaxException,
-    SchemaValidationError,
-    RasaException,
-    FileNotFoundException,
 )
 from rasa.shared.utils.constants import (
     DEFAULT_ENCODING,
-    READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR,
     DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE,
+    READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR,
 )
 from rasa.shared.utils.io import (
-    read_file,
     convert_to_ordered_dict,
     raise_warning,
+    read_file,
     read_json_file,
 )
-from ruamel import yaml as yaml
-from ruamel.yaml import YAML, RoundTripRepresenter, YAMLError
-from ruamel.yaml.comments import CommentedSeq, CommentedMap
-from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
-from ruamel.yaml.loader import SafeLoader
 
 logger = logging.getLogger(__name__)
 
@@ -699,7 +699,9 @@ def read_yaml_file(
 
 
 def read_config_file(
-    filename: Union[Path, str], reader_type: Union[str, List[str]] = "safe"
+    filename: Union[Path, str],
+    reader_type: Union[str, List[str]] = "safe",
+    expand_env_vars: bool = True,
 ) -> Dict[str, Any]:
     """Parses a yaml configuration file. Content needs to be a dictionary.
 
@@ -713,7 +715,9 @@ def read_config_file(
     Returns:
         Parsed config file.
     """
-    return read_validated_yaml(filename, CONFIG_SCHEMA_FILE, reader_type)
+    return read_validated_yaml(
+        filename, CONFIG_SCHEMA_FILE, reader_type, expand_env_vars=expand_env_vars
+    )
 
 
 def read_model_configuration(
@@ -1001,8 +1005,8 @@ def validate_yaml_with_jsonschema(
         YamlSyntaxException: if the yaml file is not valid.
         SchemaValidationError: if validation fails.
     """
-    from ruamel.yaml import YAMLError
     import importlib_resources
+    from ruamel.yaml import YAMLError
 
     schema_file = str(importlib_resources.files(package_name).joinpath(schema_path))
     schema_content = read_json_file(schema_file)

rasa/studio/auth.py

@@ -6,10 +6,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Text, Union
 
 import jwt
-from keycloak import KeycloakOpenID, KeycloakError
+from keycloak import KeycloakError, KeycloakOpenID
+
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_yaml_file, write_yaml
-
 from rasa.studio.config import StudioConfig
 from rasa.studio.constants import (
     KEYCLOAK_ACCESS_TOKEN_KEY,
@@ -17,7 +17,7 @@ from rasa.studio.constants import (
     KEYCLOAK_REFRESH_EXPIRES_IN_KEY,
     KEYCLOAK_REFRESH_TOKEN,
 )
-from rasa.studio.results_logger import with_studio_error_handler, StudioResult
+from rasa.studio.results_logger import StudioResult, with_studio_error_handler
 
 
 class StudioAuth:

rasa/studio/config.py

@@ -4,8 +4,6 @@ import os
 from dataclasses import dataclass
 from typing import Any, Dict, Optional, Text
 
-from rasa.utils.common import read_global_config_value, write_global_config_value
-
 from rasa.studio.constants import (
     RASA_STUDIO_AUTH_SERVER_URL_ENV,
     RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV,
@@ -14,6 +12,7 @@ from rasa.studio.constants import (
     RASA_STUDIO_CLI_STUDIO_URL_ENV,
     STUDIO_CONFIG_KEY,
 )
+from rasa.utils.common import read_global_config_value, write_global_config_value
 
 AUTH_SERVER_URL_KEY = "authentication_server_url"
 STUDIO_URL_KEY = "studio_url"

rasa/studio/data_handler.py

@@ -3,17 +3,17 @@ import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-import rasa.shared.utils.cli
 import requests
+
+import rasa.shared.utils.cli
 from rasa.shared.core.domain import KEY_RESPONSES, KEY_SLOTS, Domain
 from rasa.shared.core.flows.flow import Flow
 from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import read_yaml, write_yaml
-from rasa.utils.common import get_temp_dir_name
-
 from rasa.studio.auth import KeycloakToken, KeycloakTokenReader, StudioAuth
 from rasa.studio.config import StudioConfig
+from rasa.utils.common import get_temp_dir_name
 
 logger = logging.getLogger(__name__)
 

rasa/studio/download.py

@@ -9,9 +9,9 @@ import structlog
 import rasa.cli.utils
 import rasa.shared.utils.cli
 from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
     DEFAULT_DATA_PATH,
     DEFAULT_DOMAIN_PATH,
-    DEFAULT_CONFIG_PATH,
     DEFAULT_ENDPOINTS_PATH,
 )
 from rasa.shared.core.domain import Domain

rasa/studio/results_logger.py

@@ -1,13 +1,13 @@
 from dataclasses import dataclass
 from functools import wraps
-from typing import Callable, Any, Dict
+from typing import Any, Callable, Dict
 
 import structlog
 from keycloak.exceptions import KeycloakError
-from requests.exceptions import RequestException, Timeout, ConnectionError
+from requests.exceptions import ConnectionError, RequestException, Timeout
 
 from rasa.shared.exceptions import RasaException
-from rasa.shared.utils.cli import print_success, print_error
+from rasa.shared.utils.cli import print_error, print_success
 from rasa.studio.config import StudioConfig
 
 structlogger = structlog.get_logger()

rasa/studio/upload.py

@@ -2,7 +2,7 @@ import argparse
 import base64
 import re
 import sys
-from typing import Dict, Iterable, List, Set, Text, Tuple, Union, Any
+from typing import Any, Dict, Iterable, List, Set, Text, Tuple, Union
 
 import questionary
 import requests
@@ -13,13 +13,19 @@ import rasa.cli.utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
 from rasa.shared.constants import (
-    DEFAULT_DOMAIN_PATHS,
+    CONFIG_LANGUAGE_KEY,
+    CONFIG_LLM_KEY,
+    CONFIG_MODEL_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
+    CONFIG_RECIPE_KEY,
     DEFAULT_CONFIG_PATH,
+    DEFAULT_DOMAIN_PATHS,
 )
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader, YamlFlowsWriter
 from rasa.shared.exceptions import RasaException
-from rasa.shared.importers.importer import TrainingDataImporter, FlowSyncImporter
+from rasa.shared.importers.importer import FlowSyncImporter, TrainingDataImporter
 from rasa.shared.nlu.training_data.formats.rasa_yaml import (
     RasaYAMLReader,
     RasaYAMLWriter,
@@ -32,6 +38,7 @@ from rasa.studio import results_logger
 from rasa.studio.auth import KeycloakTokenReader
 from rasa.studio.config import StudioConfig
 from rasa.studio.results_logger import StudioResult, with_studio_error_handler
+from rasa.telemetry import track_upload_to_studio_failed
 
 structlogger = structlog.get_logger()
 
@@ -131,13 +138,11 @@ def handle_upload(args: argparse.Namespace) -> None:
         rasa.shared.utils.cli.print_error_and_exit(
             "No GraphQL endpoint found in config. Please run `rasa studio config`."
         )
-        return
 
     if not is_auth_working(endpoint, verify):
         rasa.shared.utils.cli.print_error_and_exit(
             "Authentication is invalid or expired. Please run `rasa studio login`."
         )
-        return
 
     structlogger.info("rasa.studio.upload.loading_data", event_info="Loading data...")
 
@@ -160,6 +165,16 @@ def handle_upload(args: argparse.Namespace) -> None:
         upload_nlu_assistant(args, endpoint, verify=verify)
 
 
+config_keys = [
+    CONFIG_RECIPE_KEY,
+    CONFIG_POLICIES_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_LANGUAGE_KEY,
+    CONFIG_LLM_KEY,
+    CONFIG_MODEL_NAME_KEY,
+]
+
+
 def extract_values(data: Dict, keys: List[Text]) -> Dict:
     """Extracts values for given keys from a dictionary."""
     return {key: data.get(key) for key in keys if data.get(key)}
@@ -382,6 +397,7 @@ def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> Studi
     )
 
     if results_logger.response_has_errors(res.json()):
+        track_upload_to_studio_failed(res.json())
         return StudioResult.error(res.json())
     return StudioResult.success("Upload successful")