rasa-pro 3.13.0.dev9__py3-none-any.whl → 3.13.0.dev11__py3-none-any.whl

rasa/shared/utils/configs.py

@@ -0,0 +1,110 @@
+from typing import Optional
+
+import structlog
+
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+
+def resolve_aliases(config: dict, deprecated_alias_mapping: dict) -> dict:
+    """
+    Resolve aliases in the configuration to standard keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping aliases to
+            their standard keys.
+
+    Returns:
+        New dictionary containing the processed configuration.
+    """
+    config = config.copy()
+
+    for alias, standard_key in deprecated_alias_mapping.items():
+        # We check for the alias instead of the standard key because our goal is to
+        # update the standard key when the alias is found. Since the standard key is
+        # always included in the default component configurations, we overwrite it
+        # with the alias value if the alias exists.
+        if alias in config:
+            config[standard_key] = config.pop(alias)
+
+    return config
+
+
+def raise_deprecation_warnings(
+    config: dict,
+    deprecated_alias_mapping: dict,
+    source: Optional[str] = None,
+) -> None:
+    """
+    Raises warnings for deprecated keys in the configuration.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping deprecated keys to
+            their standard keys.
+
+    Raises:
+        DeprecationWarning: If any deprecated key is found in the config.
+    """
+    for alias, standard_key in deprecated_alias_mapping.items():
+        if alias in config:
+            source = f"{source}: " or ""
+            raise_deprecation_warning(
+                message=(
+                    f"{source}"
+                    f"'{alias}' is deprecated and will be removed in "
+                    f"4.0.0. Use '{standard_key}' instead."
+                )
+            )
+
+
+def validate_required_keys(config: dict, required_keys: list) -> None:
+    """
+    Validates that the passed config contains all the required keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        required_keys: List of keys that must be present in the config.
+
+    Raises:
+        ValueError: If any required key is missing.
+    """
+    missing_keys = [key for key in required_keys if key not in config]
+    if missing_keys:
+        message = f"Missing required keys '{missing_keys}' for configuration."
+        structlogger.error(
+            "validate_required_keys",
+            message=message,
+            missing_keys=missing_keys,
+            config=config,
+        )
+        raise ValueError(message)
+
+
+def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
+    """
+    Validates that the passed config doesn't contain any forbidden keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        forbidden_keys: List of keys that are forbidden in the config.
+
+    Raises:
+        ValueError: If any forbidden key is present.
+    """
+    forbidden_keys_in_config = set(config.keys()).intersection(set(forbidden_keys))
+
+    if forbidden_keys_in_config:
+        message = (
+            f"Forbidden keys '{forbidden_keys_in_config}' present "
+            f"in the configuration."
+        )
+        structlogger.error(
+            "validate_forbidden_keys",
+            message=message,
+            forbidden_keys=forbidden_keys_in_config,
+            config=config,
+        )
+        raise ValueError(message)

rasa/shared/utils/constants.py

@@ -2,9 +2,6 @@ DEFAULT_ENCODING = "utf-8"
 
 READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR = "READ_YAML_FILE_CACHE_MAXSIZE"
 DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE = 256
-RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME = (
-    "RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS"
-)
 
 LOG_COMPONENT_SOURCE_METHOD_INIT = "init"
 LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON = "fingerprint_addon"

rasa/shared/utils/pykwalify_extensions.py

@@ -8,11 +8,6 @@ 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
@@ -31,10 +26,6 @@ def require_response_keys(
 
         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:

rasa/studio/constants.py

@@ -14,6 +14,7 @@ RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV = "RASA_STUDIO_CLI_DISABLE_VERIFY_KEY"
 
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"
+DOMAIN_FILENAME = "domain.yml"
 STUDIO_FLOWS_FILENAME = "studio_flows.yml"
 STUDIO_CONFIG_FILENAME = "studio_config.yml"
 STUDIO_ENDPOINTS_FILENAME = "studio_endpoints.yml"

rasa/studio/download.py

@@ -0,0 +1,164 @@
+import argparse
+import shutil
+from pathlib import Path
+from typing import Dict
+
+import questionary
+import structlog
+from ruamel import yaml
+from ruamel.yaml.scalarstring import LiteralScalarString
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.shared.core.flows.yaml_flows_io import FlowsList
+from rasa.shared.nlu.training_data.training_data import (
+    DEFAULT_TRAINING_DATA_OUTPUT_PATH,
+)
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.constants import DOMAIN_FILENAME
+from rasa.studio.data_handler import StudioDataHandler
+from rasa.studio.pull.data import _dump_flows_as_separate_files
+
+structlogger = structlog.get_logger()
+
+
+def handle_download(args: argparse.Namespace) -> None:
+    """Download an assistant from Studio and store it in `<assistant_name>/`.
+
+    Args:
+        args: The command line arguments.
+    """
+    assistant_name = args.assistant_name
+    target_root = _prepare_target_directory(assistant_name)
+
+    handler = StudioDataHandler(
+        studio_config=StudioConfig.read_config(), assistant_name=assistant_name
+    )
+    handler.request_all_data()
+
+    _handle_config(handler, target_root)
+    _handle_endpoints(handler, target_root)
+    _handle_domain(handler, target_root)
+    _handle_data(handler, target_root)
+    structlogger.info(
+        "studio.download.success",
+        event_info=f"Downloaded assistant '{assistant_name}' from Studio.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Downloaded assistant '{assistant_name}' from Studio."
+    )
+
+
+def _prepare_target_directory(assistant_name: str) -> Path:
+    """Create (or overwrite) the directory where everything is stored.
+
+    Args:
+        assistant_name: The name of the assistant to download.
+
+    Returns:
+        The path to the target directory where the assistant will be stored.
+    """
+    target_root = Path(assistant_name)
+
+    if target_root.exists():
+        overwrite = questionary.confirm(
+            f"Directory '{assistant_name}' already exists. Overwrite it?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_error_and_exit("Download cancelled.")
+
+        shutil.rmtree(target_root)
+
+    target_root.mkdir(parents=True, exist_ok=True)
+    return target_root
+
+
+def _handle_config(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s config file.
+
+    Args:
+        handler: The data handler to retrieve the config from.
+        root: The root directory where the config file will be stored.
+    """
+    config_data = handler.get_config()
+    if not config_data:
+        rasa.shared.utils.cli.print_error_and_exit("No config data found.")
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    config_path.write_text(config_data, encoding="utf-8")
+
+
+def _handle_endpoints(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s endpoints file.
+
+    Args:
+        handler: The data handler to retrieve the endpoints from.
+        root: The root directory where the endpoints file will be stored.
+    """
+    endpoints_data = handler.get_endpoints()
+    if not endpoints_data:
+        rasa.shared.utils.cli.print_error_and_exit("No endpoints data found.")
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    endpoints_path.write_text(endpoints_data, encoding="utf-8")
+
+
+def _handle_domain(handler: StudioDataHandler, root: Path) -> None:
+    """Persist the assistant’s domain file.
+
+    Args:
+        handler: The data handler to retrieve the domain from.
+        root: The root directory where the domain file will be stored.
+    """
+    domain_yaml = handler.domain
+    data = read_yaml(domain_yaml)
+    target = root / DOMAIN_FILENAME
+    write_yaml(
+        data=data,
+        target=target,
+        should_preserve_key_order=True,
+    )
+
+
+def _handle_data(handler: StudioDataHandler, root: Path) -> None:
+    """Persist NLU data and flows.
+
+    Args:
+        handler: The data handler to retrieve the NLU data and flows from.
+        root: The root directory where the NLU data and flows will be stored.
+    """
+    data_path = root / DEFAULT_DATA_PATH
+    data_path.mkdir(parents=True, exist_ok=True)
+
+    if handler.has_nlu():
+        nlu_yaml = handler.nlu
+        nlu_data = read_yaml(nlu_yaml)
+        if nlu_data.get("nlu"):
+            pretty_write_nlu_yaml(
+                nlu_data, data_path / DEFAULT_TRAINING_DATA_OUTPUT_PATH
+            )
+
+    if handler.has_flows():
+        flows_yaml = handler.flows
+        data = read_yaml(flows_yaml)
+        flows_data = data.get("flows", {})
+        flows_list = FlowsList.from_json(flows_data)
+        _dump_flows_as_separate_files(flows_list.underlying_flows, data_path)
+
+
+def pretty_write_nlu_yaml(data: Dict, file: Path) -> None:
+    """Writes the NLU YAML in a pretty way."""
+    dumper = yaml.YAML()
+    if nlu_data := data.get("nlu"):
+        for item in nlu_data:
+            if item.get("examples"):
+                item["examples"] = LiteralScalarString(item["examples"])
+    with file.open("w", encoding="utf-8") as outfile:
+        dumper.dump(data, outfile)

rasa/studio/link.py

@@ -167,7 +167,7 @@ def handle_link(args: argparse.Namespace) -> None:
     Args:
         args: The command line arguments.
     """
-    assistant_name: Text = args.assistant_name[0]
+    assistant_name: Text = args.assistant_name
     studio_cfg = get_studio_config()
     assistant_exists = _ensure_assistant_exists(assistant_name, studio_cfg, args)
     if not assistant_exists:

rasa/studio/{download/flows.py → pull/data.py}

@@ -3,101 +3,16 @@ from pathlib import Path
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.core.flows import Flow
-from rasa.shared.core.flows.flow_step_links import StaticFlowStepLink
 from rasa.shared.core.flows.flows_list import FlowsList
 from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader, YamlFlowsWriter
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import read_yaml
 from rasa.studio.constants import STUDIO_NLU_FILENAME
-from rasa.studio.data_handler import StudioDataHandler
 from rasa.utils.mapper import RasaPrimitiveStorageMapper
 
 logger = logging.getLogger(__name__)
 
-STUDIO_FLOWS_DIR_NAME = "studio_flows"
-
-
-def merge_flows_with_overwrite(
-    data_path: Path,
-    handler: Any,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    mapper: RasaPrimitiveStorageMapper,
-) -> None:
-    """
-    Merges flows data from a file or directory when overwrite is enabled.
-
-    Args:
-        data_path: List of paths to the training data.
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-    """
-    if data_path.is_file():
-        merge_training_data_file(handler, data_from_studio, data_local, data_path)
-    elif data_path.is_dir():
-        merge_training_data_dir(
-            handler, data_from_studio, data_local, data_path, mapper
-        )
-    else:
-        raise ValueError("Provided data path is neither a file nor a directory.")
-
-
-def merge_training_data_file(
-    handler: StudioDataHandler,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    file_path: Path,
-) -> None:
-    """
-    Merges NLU and flows data when training data is stored in a single file.
-
-    Args:
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        file_path: The path to the training data file.
-    """
-    if handler.has_nlu():
-        nlu_data_merged = data_from_studio.get_nlu_data().merge(
-            data_local.get_nlu_data()
-        )
-        nlu_data_merged.persist_nlu(file_path)
-
-    if handler.has_flows():
-        flows_data_merged = data_from_studio.get_user_flows().merge(
-            data_local.get_user_flows()
-        )
-        YamlFlowsWriter.dump(
-            flows=flows_data_merged.underlying_flows,
-            filename=file_path,
-            should_clean_json=True,
-        )
-
-
-def merge_training_data_dir(
-    handler: StudioDataHandler,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    data_path: Path,
-    mapper: RasaPrimitiveStorageMapper,
-) -> None:
-    """
-    Merges NLU and flows data when training data is stored in a directory.
-
-    Args:
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        data_path: The path to the training data directory.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-    """
-    if handler.has_nlu():
-        merge_nlu_in_directory(data_from_studio, data_local, data_path, mapper)
-
-    if handler.has_flows():
-        merge_flows_in_directory(data_from_studio, data_path, mapper)
+STUDIO_FLOWS_DIR_NAME = "flows"
 
 
 def merge_nlu_in_directory(
@@ -116,7 +31,7 @@ def merge_nlu_in_directory(
         data_path: The path to the training data directory.
         mapper: The RasaPrimitiveStorageMapper instance for mapping.
     """
-    from rasa.studio.download.download import pretty_write_nlu_yaml
+    from rasa.studio.download import pretty_write_nlu_yaml
 
     nlu_data = data_from_studio.get_nlu_data()
     nlu_file_path = get_nlu_path(data_path, data_local, mapper)
@@ -154,29 +69,6 @@ def get_nlu_path(
     return _select_path(nlu_paths, "nlu", base_path, STUDIO_NLU_FILENAME)
 
 
-def get_flows_path(
-    base_path: Path,
-    data_local: TrainingDataImporter,
-    mapper: RasaPrimitiveStorageMapper,
-) -> Path:
-    """Determines where flows data should be stored.
-
-    Args:
-        base_path: The base path for the training data.
-        data_local: The TrainingDataImporter instance for local data.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-
-    Returns:
-        The path where flows data should be stored.
-    """
-    flow_paths = set()
-    for flow in data_local.get_user_flows().underlying_flows:
-        for p in mapper.get_file(flow.id, "flows").get("training", []):
-            flow_paths.add(p)
-
-    return _select_path(flow_paths, "flows", base_path, "flows.yml")
-
-
 def merge_flows_in_directory(
     data_from_studio: TrainingDataImporter,
     data_path: Path,
@@ -298,27 +190,6 @@ def _dump_flows_as_separate_files(flows: List[Any], data_path: Path) -> None:
         )
 
 
-def strip_default_next_references(flows: FlowsList) -> FlowsList:
-    """Strips default next references from flows.
-
-    Args:
-        flows: The FlowsList instance containing the flows.
-
-    Returns:
-        An updated FlowsList instance with default next references removed.
-    """
-    default_step_ids = [step.default_id for flow in flows for step in flow.steps]
-    for flow in flows:
-        for step in flow.steps:
-            if (
-                step.next.links
-                and isinstance(step.next.links[0], StaticFlowStepLink)
-                and step.next.links[0].target in default_step_ids
-            ):
-                step.next.links = []
-    return flows
-
-
 def _select_path(
     paths: Set[Path], primitive_type: str, default_path: Path, default: str
 ) -> Path:

rasa/studio/{download → pull}/domains.py

@@ -10,7 +10,7 @@ from rasa.studio.constants import STUDIO_DOMAIN_FILENAME
 logger = logging.getLogger(__name__)
 
 
-def merge_domain_with_overwrite(
+def merge_domain(
     data_from_studio: TrainingDataImporter,
     data_local: TrainingDataImporter,
     domain_path: Path,