rasa-pro 3.11.0rc2__py3-none-any.whl → 3.11.1__py3-none-any.whl

rasa/studio/upload.py

@@ -1,5 +1,6 @@
 import argparse
 import base64
+import re
 import sys
 from typing import Dict, Iterable, List, Set, Text, Tuple, Union, Any
 
@@ -15,11 +16,18 @@ from rasa.shared.constants import (
     DEFAULT_DOMAIN_PATHS,
     DEFAULT_CONFIG_PATH,
 )
-from rasa.shared.core.flows.yaml_flows_io import YamlFlowsWriter
+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.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
-from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string, read_yaml_file
+from rasa.shared.nlu.training_data.formats.rasa_yaml import (
+    RasaYAMLReader,
+    RasaYAMLWriter,
+)
+from rasa.shared.utils.yaml import (
+    dump_obj_as_yaml_to_string,
+    read_yaml_file,
+)
 from rasa.studio import results_logger
 from rasa.studio.auth import KeycloakTokenReader
 from rasa.studio.config import StudioConfig
@@ -27,6 +35,27 @@ from rasa.studio.results_logger import StudioResult, with_studio_error_handler
 
 structlogger = structlog.get_logger()
 
+CONFIG_KEYS = [
+    "recipe",
+    "language",
+    "pipeline",
+    "llm",
+    "policies",
+    "model_name",
+    "assistant_id",
+]
+
+DOMAIN_KEYS = [
+    "version",
+    "actions",
+    "responses",
+    "slots",
+    "intents",
+    "entities",
+    "forms",
+    "session_config",
+]
+
 
 def _get_selected_entities_and_intents(
     args: argparse.Namespace,
@@ -54,6 +83,44 @@ def _get_selected_entities_and_intents(
     return list(entities), list(intents)
 
 
+def run_validation(args: argparse.Namespace) -> None:
+    """Run the validation before uploading to Studio.
+
+    This is to avoid uploading invalid assistant data
+    that would raise errors during Rasa Pro training in Studio.
+
+    The validation checks that were selected to be run before uploading
+    maintain parity with the features that are supported in Studio.
+    """
+    from rasa.validator import Validator
+
+    training_data_importer = TrainingDataImporter.load_from_dict(
+        domain_path=args.domain,
+        training_data_paths=args.data,
+        config_path=args.config,
+        expand_env_vars=False,
+    )
+
+    structlogger.info(
+        "rasa.studio.upload.validating_data",
+        event_info="Validating domain and training data...",
+    )
+
+    validator = Validator.from_importer(training_data_importer)
+
+    if not validator.verify_studio_supported_validations():
+        structlogger.error(
+            "rasa.studio.upload.validate_files.project_validation_error",
+            event_info="Project validation completed with errors.",
+        )
+        sys.exit(1)
+
+    structlogger.info(
+        "rasa.studio.upload.validate_files.success",
+        event_info="Project validation completed successfully.",
+    )
+
+
 def handle_upload(args: argparse.Namespace) -> None:
     """Uploads primitives to rasa studio."""
     studio_config = StudioConfig.read_config()
@@ -82,6 +149,10 @@ def handle_upload(args: argparse.Namespace) -> None:
         args.config, "config", DEFAULT_CONFIG_PATH
     )
 
+    Domain.expand_env_vars = False
+    RasaYAMLReader.expand_env_vars = False
+    YAMLFlowsReader.expand_env_vars = False
+
     # check safely if args.calm is set and not fail if not
     if hasattr(args, "calm") and args.calm:
         upload_calm_assistant(args, endpoint, verify=verify)
@@ -89,17 +160,6 @@ def handle_upload(args: argparse.Namespace) -> None:
         upload_nlu_assistant(args, endpoint, verify=verify)
 
 
-config_keys = [
-    "recipe",
-    "language",
-    "pipeline",
-    "llm",
-    "policies",
-    "model_name",
-    "assistant_id",
-]
-
-
 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)}
@@ -141,7 +201,7 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
 def upload_calm_assistant(
     args: argparse.Namespace, endpoint: str, verify: bool = True
 ) -> StudioResult:
-    """Uploads the CALM assistant data to Rasa Studio.
+    """Validates and uploads the CALM assistant data to Rasa Studio.
 
     Args:
         args: The command line arguments
@@ -154,6 +214,8 @@ def upload_calm_assistant(
     Returns:
         None
     """
+    run_validation(args)
+
     structlogger.info(
         "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
     )
@@ -161,71 +223,48 @@ def upload_calm_assistant(
     importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
         config_path=args.config,
+        expand_env_vars=False,
     )
 
     # Prepare config and domain
     config = importer.get_config()
+    assistant_name = _get_assistant_name(config)
+    config_from_files = read_yaml_file(args.config, expand_env_vars=False)
     domain_from_files = importer.get_user_domain().as_dict()
-    endpoints_from_files = read_yaml_file(args.endpoints)
-    config_from_files = read_yaml_file(args.config)
 
     # Extract domain and config values
-    domain_keys = [
-        "version",
-        "actions",
-        "responses",
-        "slots",
-        "intents",
-        "entities",
-        "forms",
-        "session_config",
-    ]
-
-    domain = extract_values(domain_from_files, domain_keys)
-
-    assistant_name = _get_assistant_name(config)
-
-    training_data_paths = args.data
-
-    if isinstance(training_data_paths, list):
-        training_data_paths.append(args.flows)
-    elif isinstance(training_data_paths, str):
-        if isinstance(args.flows, list):
-            training_data_paths = [training_data_paths] + args.flows
-        elif isinstance(args.flows, str):
-            training_data_paths = [training_data_paths, args.flows]
-        else:
-            raise RasaException("Invalid flows path")
+    domain = extract_values(domain_from_files, DOMAIN_KEYS)
 
     # Prepare flows
     flow_importer = FlowSyncImporter.load_from_dict(
-        training_data_paths=training_data_paths
+        training_data_paths=args.data, expand_env_vars=False
     )
-
     flows = list(flow_importer.get_user_flows())
 
     # We instantiate the TrainingDataImporter again on purpose to avoid
     # adding patterns to domain's actions. More info https://t.ly/W8uuc
     nlu_importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain, training_data_paths=args.data
+        training_data_paths=args.data, expand_env_vars=False
     )
     nlu_data = nlu_importer.get_nlu_data()
-
-    intents_from_files = nlu_data.intents
-
     nlu_examples = nlu_data.filter_training_examples(
-        lambda ex: ex.get("intent") in intents_from_files
+        lambda ex: ex.get("intent") in nlu_data.intents
     )
-
     nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
 
+    # Prepare endpoints
+    endpoints_from_files = read_yaml_file(args.endpoints, expand_env_vars=False)
+    endpoints_str = dump_obj_as_yaml_to_string(
+        endpoints_from_files, transform=remove_quotes
+    )
+
     # Build GraphQL request
     graphql_req = build_import_request(
         assistant_name,
         flows_yaml=YamlFlowsWriter().dumps(flows),
         domain_yaml=dump_obj_as_yaml_to_string(domain),
         config_yaml=dump_obj_as_yaml_to_string(config_from_files),
-        endpoints=dump_obj_as_yaml_to_string(endpoints_from_files),
+        endpoints=endpoints_str,
         nlu_yaml=nlu_examples_yaml,
     )
 
@@ -257,18 +296,22 @@ def upload_nlu_assistant(
         event_info="Found DM1 assistant data, parsing...",
     )
     importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain, training_data_paths=args.data, config_path=args.config
+        domain_path=args.domain,
+        training_data_paths=args.data,
+        config_path=args.config,
+        expand_env_vars=False,
     )
 
     intents_from_files = importer.get_nlu_data().intents
-    entities_from_files = importer.get_domain().entities
 
+    domain_from_files = importer.get_domain()
+    entities_from_files = domain_from_files.entities
     entities, intents = _get_selected_entities_and_intents(
         args, intents_from_files, entities_from_files
     )
 
     config_from_files = importer.get_config()
-    config = extract_values(config_from_files, config_keys)
+    config = extract_values(config_from_files, CONFIG_KEYS)
 
     assistant_name = _get_assistant_name(config)
 
@@ -286,7 +329,7 @@ def upload_nlu_assistant(
     all_entities = _add_missing_entities(nlu_examples.entities, entities)
     nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
 
-    domain = _filter_domain(all_entities, intents, importer.get_domain().as_dict())
+    domain = _filter_domain(all_entities, intents, domain_from_files.as_dict())
     domain_yaml = dump_obj_as_yaml_to_string(domain)
 
     graphql_req = build_request(assistant_name, nlu_examples_yaml, domain_yaml)
@@ -424,7 +467,9 @@ def build_request(
 
 
 def _filter_domain(
-    entities: List[Union[str, Dict]], intents: List[str], domain_from_files: Dict
+    entities: List[Union[str, Dict]],
+    intents: List[str],
+    domain_from_files: Dict[str, Any],
 ) -> Dict:
     """Filters the domain to only include the selected entities and intents."""
     selected_entities = _remove_not_selected_entities(
@@ -485,3 +530,20 @@ def _remove_not_selected_entities(
         domain_entities.remove(entity)
 
     return domain_entities
+
+
+def remove_quotes(node: Any) -> Any:
+    """Transform function to remove quotes from a node if it is a string.
+
+    This is to prevent wrapping unexpanded environment variables in quotes
+    when uploading endpoints to Rasa Studio.
+    """
+    if isinstance(node, str):
+        matches = re.findall(r"'\$\{([^}]+)\}'", node)
+        for match in matches:
+            node = node.replace(f"'${{{match}}}'", f"${{{match}}}")
+        return node
+    elif isinstance(node, dict):
+        return {k: remove_quotes(v) for k, v in node.items()}
+    else:
+        return node

rasa/telemetry.py

@@ -35,9 +35,9 @@ from rasa.constants import (
 from rasa.shared.constants import (
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
     LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
+    MODEL_GROUP_CONFIG_KEY,
 )
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.shared.constants import DOCS_URL_TELEMETRY, UTTER_ASK_PREFIX
@@ -1133,6 +1133,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     def extract_llm_command_generator_llm_client_settings(component: Dict) -> Dict:
         """Extracts settings related to LLM command generator."""
         llm_config = component.get(LLM_CONFIG_KEY, {})
+        # Config at this stage is not yet resolved, so read from `model_group`
         llm_model_group_id = llm_config.get(MODEL_GROUP_CONFIG_KEY)
         llm_model_name = llm_config.get(MODEL_CONFIG_KEY) or llm_config.get(
             MODEL_NAME_CONFIG_KEY
@@ -1174,6 +1175,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
             if flow_retrieval_enabled
             else None
         )
+        # Config at this stage is not yet resolved, so read from `model_group`
         flow_retrieval_embedding_model_group_id = embeddings_config.get(
             MODEL_GROUP_CONFIG_KEY
         )

rasa/tracing/config.py

@@ -131,7 +131,7 @@ def get_tracer_provider(endpoints_file: Text) -> Optional[TracerProvider]:
 
     if not cfg:
         logger.info(
-            f"No endpoint for tracing type available in {endpoints_file},"
+            f"No endpoint for tracing type available in {endpoints_file}, "
             f"tracing will not be configured."
         )
         return None

rasa/validator.py

@@ -1,6 +1,7 @@
 import logging
 import re
 import string
+import sys
 from collections import defaultdict
 from typing import Set, Text, Optional, Dict, Any, List, Tuple
 
@@ -304,7 +305,7 @@ class Validator:
             return any(cls.check_for_placeholder(i) for i in value)
         return False
 
-    def check_for_no_empty_paranthesis_in_responses(self) -> bool:
+    def check_for_no_empty_parenthesis_in_responses(self) -> bool:
         """Checks if there are no empty parenthesis in utterances."""
         everything_is_alright = True
 
@@ -315,12 +316,12 @@ class Validator:
                     for key in RESPONSE_KEYS_TO_INTERPOLATE
                 ):
                     structlogger.error(
-                        "validator.empty_paranthesis_in_utterances",
+                        "validator.empty_parenthesis_in_utterances",
                         response=response_text,
                         event_info=(
                             f"The response '{response_text}' in the domain file "
-                            f"contains empty parenthesis, which is not permitted."
-                            f" Please remove the empty parenthesis."
+                            f"contains empty parenthesis, which is not permitted. "
+                            f"Please remove the empty parenthesis."
                         ),
                     )
                     everything_is_alright = False
@@ -1603,3 +1604,38 @@ class Validator:
                 ),
             )
         return is_valid
+
+    def verify_studio_supported_validations(self) -> bool:
+        """Validates the assistant project for Rasa Studio supported features.
+
+        Ensure to add new validations here if they are required for
+        Rasa Studio Upload CLI.
+        """
+        if self.domain.is_empty():
+            structlogger.error(
+                "rasa.validator.verify_studio_supported_validations.empty_domain",
+                event_info="Encountered empty domain during validation.",
+            )
+            sys.exit(1)
+
+        self.warn_if_config_mandatory_keys_are_not_set()
+
+        valid_responses = (
+            self.check_for_no_empty_parenthesis_in_responses()
+            and self.validate_button_payloads()
+        )
+        valid_nlu = self.verify_nlu()
+        valid_flows = all(
+            [
+                self.verify_flows_steps_against_domain(),
+                self.verify_unique_flows(),
+                self.verify_predicates(),
+            ]
+        )
+        valid_calm_slot_mappings = self.validate_CALM_slot_mappings()
+
+        all_good = (
+            valid_responses and valid_nlu and valid_flows and valid_calm_slot_mappings
+        )
+
+        return all_good

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.11.0rc2"
+__version__ = "3.11.1"

{rasa_pro-3.11.0rc2.dist-info → rasa_pro-3.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.11.0rc2
+Version: 3.11.1
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
@@ -103,7 +103,7 @@ Requires-Dist: pyyaml (>=6.0)
 Requires-Dist: qdrant-client (>=1.9.0,<2.0.0)
 Requires-Dist: questionary (>=1.10.0,<2.1.0)
 Requires-Dist: randomname (>=0.2.1,<0.3.0)
-Requires-Dist: rasa-sdk (==3.11.0rc1)
+Requires-Dist: rasa-sdk (==3.11.0)
 Requires-Dist: redis (>=4.6.0,<6.0)
 Requires-Dist: regex (>=2022.10.31,<2022.11)
 Requires-Dist: requests (>=2.31.0,<2.32.0)