rasa-pro 3.12.21__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/studio/pull/domains.py

@@ -0,0 +1,60 @@
+import logging
+from pathlib import Path
+
+from rasa.shared.core.domain import (
+    Domain,
+)
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.studio.constants import STUDIO_DOMAIN_FILENAME
+
+logger = logging.getLogger(__name__)
+
+
+def merge_domain(
+    data_from_studio: TrainingDataImporter,
+    data_local: TrainingDataImporter,
+    domain_path: Path,
+) -> None:
+    """Merges the domain from Rasa Studio with the local domain.
+
+    Args:
+        data_from_studio: The training data importer for the Rasa Studio domain.
+        data_local: The training data importer for the local domain.
+        domain_path: The path to the domain file or directory.
+    """
+    if domain_path.is_file():
+        all_local_domain_files = [str(domain_path)]
+        domain_path = domain_path.parent
+    else:
+        all_local_domain_files = data_local.get_domain_files([str(domain_path)])
+
+    studio_domain_file_path = domain_path / STUDIO_DOMAIN_FILENAME
+
+    # leftover_domain represents the items in the studio
+    # domain that are not in the local domain
+    leftover_domain = data_from_studio.get_user_domain()
+    for file_path in all_local_domain_files:
+        if file_path == str(studio_domain_file_path):
+            # we need to exclude the studio domain file from the merge,
+            # since we want to dump ALL the remaining items to this path
+            # after the merge. if we include it here, we will remove the existing
+            # items from the leftover domain and after this loop we will
+            # overwrite the studio domain file with the remaining items in
+            # the leftover domain - this means we loose the items that were
+            # in the studio domain file before we started the merge.
+            continue
+
+        # For each local domain file, we do a partial merge
+        local_domain = Domain.from_file(str(file_path))
+        updated_local_domain = local_domain.partial_merge(leftover_domain)
+
+        # If this partial merge made changes, persist them
+        if local_domain != updated_local_domain:
+            updated_local_domain.persist(file_path)
+
+        # Remove every item now present in updated_local_domain from leftover_domain
+        leftover_domain = leftover_domain.difference(updated_local_domain)
+
+    # If there are still items in leftover_domain, persist them
+    if not leftover_domain.is_empty():
+        leftover_domain.persist(studio_domain_file_path)

rasa/studio/pull/pull.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any, Tuple
+
+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_DOMAIN_PATHS,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.io import write_text_file
+from rasa.studio.config import StudioConfig
+from rasa.studio.data_handler import StudioDataHandler, import_data_from_studio
+from rasa.studio.link import read_assistant_name
+from rasa.studio.pull.data import merge_flows_in_directory, merge_nlu_in_directory
+from rasa.studio.pull.domains import merge_domain
+from rasa.studio.utils import validate_argument_paths
+from rasa.utils.mapper import RasaPrimitiveStorageMapper
+
+structlogger = structlog.get_logger(__name__)
+
+
+def handle_pull(args: argparse.Namespace) -> None:
+    """Pull the complete assistant and overwrite all local files.
+
+    Args:
+        args: The command line arguments.
+    """
+    validate_argument_paths(args)
+    handler = _create_studio_handler()
+    handler.request_all_data()
+
+    _pull_config_file(handler, args.config or DEFAULT_CONFIG_PATH)
+    _pull_endpoints_file(handler, args.endpoints or DEFAULT_ENDPOINTS_PATH)
+
+    domain_path, data_path = _prepare_data_and_domain_paths(args)
+    _merge_domain_and_data(handler, domain_path, data_path)
+
+    structlogger.info(
+        "studio.push.success",
+        event_info="Pulled assistant data from Studio.",
+    )
+    rasa.shared.utils.cli.print_success("Pulled assistant data from Studio.")
+
+
+def handle_pull_config(args: argparse.Namespace) -> None:
+    """Pull nothing but the assistant's `config.yml`.
+
+    Args:
+        args: The command line arguments.
+    """
+    validate_argument_paths(args)
+    handler = _create_studio_handler()
+    handler.request_all_data()
+
+    _pull_config_file(handler, args.config or DEFAULT_CONFIG_PATH)
+
+    structlogger.info(
+        "studio.push.success",
+        event_info="Pulled assistant data from Studio.",
+    )
+    rasa.shared.utils.cli.print_success("Pulled assistant data from Studio.")
+
+
+def handle_pull_endpoints(args: argparse.Namespace) -> None:
+    """Pull nothing but the assistant's `endpoints.yml`.
+
+    Args:
+        args: The command line arguments.
+    """
+    validate_argument_paths(args)
+    handler = _create_studio_handler()
+    handler.request_all_data()
+
+    _pull_endpoints_file(handler, args.endpoints or DEFAULT_ENDPOINTS_PATH)
+    structlogger.info(
+        "studio.push.success",
+        event_info="Pulled assistant data from Studio.",
+    )
+    rasa.shared.utils.cli.print_success("Pulled assistant data from Studio.")
+
+
+def _create_studio_handler() -> StudioDataHandler:
+    """Return an initialised StudioDataHandler for the linked assistant.
+
+    Returns:
+        An instance of `StudioDataHandler` for the linked assistant.
+    """
+    assistant_name = read_assistant_name()
+    return StudioDataHandler(
+        studio_config=StudioConfig.read_config(), assistant_name=assistant_name
+    )
+
+
+def _pull_config_file(handler: StudioDataHandler, target_path: str | Path) -> None:
+    """Pull the assistant's `config.yml` file and write it to the specified path.
+
+    Args:
+        handler: The data handler to retrieve the config from.
+        target_path: The path where the config file should be written.
+    """
+    config_yaml = handler.get_config()
+    if not config_yaml:
+        rasa.shared.utils.cli.print_error_and_exit("No config data found in assistant.")
+
+    _write_text(config_yaml, target_path)
+
+
+def _pull_endpoints_file(handler: StudioDataHandler, target_path: str | Path) -> None:
+    """Pull the assistant's `endpoints.yml` file and write it to the specified path.
+
+    Args:
+        handler: The data handler to retrieve the endpoints from.
+        target_path: The path where the endpoints file should be written.
+    """
+    endpoints_yaml = handler.get_endpoints()
+    if not endpoints_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No endpoints data found in assistant."
+        )
+
+    _write_text(endpoints_yaml, target_path)
+
+
+def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, Path]:
+    """Prepars the domain and data paths based on the provided arguments.
+
+    Args:
+        args: The command line arguments.
+
+    Returns:
+        A tuple containing the domain path and a data path.
+    """
+    # Prepare domain path.
+    domain_path = rasa.cli.utils.get_validated_path(
+        args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
+    )
+    domain_or_default_path = args.domain or DEFAULT_DOMAIN_PATH
+
+    if domain_path is None:
+        domain_path = Path(domain_or_default_path)
+        domain_path.touch()
+
+    if isinstance(domain_path, str):
+        domain_path = Path(domain_path)
+
+    data_path = rasa.cli.utils.get_validated_path(
+        args.data, "data", DEFAULT_DATA_PATH, none_is_valid=True
+    )
+
+    data_path = Path(data_path or args.data)
+    if not (data_path.is_file() or data_path.is_dir()):
+        data_path.mkdir(parents=True, exist_ok=True)
+
+    return domain_path, data_path
+
+
+def _merge_domain_and_data(
+    handler: StudioDataHandler, domain_path: Path, data_path: Path
+) -> None:
+    """Merge local assistant data with Studio assistant data.
+
+    Args:
+        handler: The data handler to retrieve the assistant data from.
+        domain_path: The path to the local domain file or directory.
+        data_path: The path to the local training data file or directory.
+    """
+    data_from_studio, data_local = import_data_from_studio(
+        handler, domain_path, data_path
+    )
+    mapper = RasaPrimitiveStorageMapper(
+        domain_path=domain_path, training_data_paths=[data_path]
+    )
+
+    merge_domain(data_from_studio, data_local, domain_path)
+    merge_data(data_path, handler, data_from_studio, data_local, mapper)
+
+
+def merge_data(
+    data_path: Path,
+    handler: Any,
+    data_from_studio: TrainingDataImporter,
+    data_local: TrainingDataImporter,
+    mapper: RasaPrimitiveStorageMapper,
+) -> None:
+    """
+    Merges flows data from a file or directory.
+
+    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 not data_path.is_file() and not data_path.is_dir():
+        raise ValueError("Provided data path is neither a file nor a directory.")
+
+    if handler.has_nlu():
+        if data_path.is_file():
+            nlu_data_merged = data_from_studio.get_nlu_data().merge(
+                data_local.get_nlu_data()
+            )
+            nlu_data_merged.persist_nlu(data_path)
+        else:
+            merge_nlu_in_directory(
+                data_from_studio,
+                data_local,
+                data_path,
+                mapper,
+            )
+
+    if handler.has_flows():
+        flows_root = data_path.parent if data_path.is_file() else data_path
+        merge_flows_in_directory(
+            data_from_studio,
+            flows_root,
+            mapper,
+        )
+
+
+def _write_text(content: str, target: str | Path) -> None:
+    """Write `content` to `target`, ensuring parent directories exist.
+
+    Args:
+        content: The content to write to the file.
+        target: The path where the content should be written.
+    """
+    path = Path(target)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    write_text_file(content, path, encoding="utf-8")

rasa/studio/push.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Dict, Text
+
+import structlog
+
+import rasa.shared.utils.cli
+from rasa.shared.core.flows.yaml_flows_io import YamlFlowsWriter
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
+from rasa.shared.utils.io import read_file
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+from rasa.studio.config import StudioConfig
+from rasa.studio.link import get_studio_config, read_assistant_name
+from rasa.studio.upload import (
+    build_import_request,
+    make_request,
+    run_validation,
+)
+from rasa.studio.utils import validate_argument_paths
+
+structlogger = structlog.get_logger(__name__)
+
+
+def _send_to_studio(
+    assistant_name: Text,
+    payload_parts: Dict[Text, Text],
+    studio_cfg: StudioConfig,
+) -> None:
+    """Build the GraphQL request and send it.
+
+    Args:
+        assistant_name: The name of the assistant.
+        payload_parts: The parts of the payload to send.
+        studio_cfg: The StudioConfig object.
+    """
+    graphql_req = build_import_request(
+        assistant_name=assistant_name,
+        flows_yaml=payload_parts.get("flows"),
+        domain_yaml=payload_parts.get("domain"),
+        config_yaml=payload_parts.get("config"),
+        endpoints=payload_parts.get("endpoints"),
+        nlu_yaml=payload_parts.get("nlu"),
+    )
+    verify = not studio_cfg.disable_verify
+    result = make_request(studio_cfg.studio_url, graphql_req, verify)
+    if not result.was_successful:
+        rasa.shared.utils.cli.print_error_and_exit(result.message)
+
+    structlogger.info(
+        "studio.push.success",
+        event_info=f"Pushed data to assistant '{assistant_name}'.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(f"Pushed data to assistant '{assistant_name}'.")
+
+
+def handle_push(args: argparse.Namespace) -> None:
+    """Push the entire assistant.
+
+    Args:
+        args: The command line arguments.
+    """
+    validate_argument_paths(args)
+    studio_cfg = get_studio_config()
+
+    run_validation(args)
+
+    importer = TrainingDataImporter.load_from_dict(
+        domain_path=args.domain,
+        config_path=args.config,
+        expand_env_vars=False,
+    )
+
+    domain_yaml = dump_obj_as_yaml_to_string(importer.get_user_domain().as_dict())
+    config_yaml = read_file(Path(args.config))
+    endpoints_yaml = read_file(Path(args.endpoints))
+
+    flow_importer = TrainingDataImporter.load_from_dict(
+        training_data_paths=args.data, expand_env_vars=False
+    )
+    flows_yaml = YamlFlowsWriter().dumps(flow_importer.get_user_flows())
+
+    nlu_importer = TrainingDataImporter.load_from_dict(
+        training_data_paths=args.data, expand_env_vars=False
+    )
+    nlu_yaml = RasaYAMLWriter().dumps(nlu_importer.get_nlu_data())
+
+    assistant_name = read_assistant_name()
+    _send_to_studio(
+        assistant_name,
+        {
+            "flows": flows_yaml,
+            "domain": domain_yaml,
+            "config": config_yaml,
+            "endpoints": endpoints_yaml,
+            "nlu": nlu_yaml,
+        },
+        studio_cfg,
+    )
+
+
+def handle_push_config(args: argparse.Namespace) -> None:
+    """Push only the assistant configuration (config.yml).
+
+    Args:
+        args: The command line arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    config_yaml = read_file(Path(args.config))
+    if not config_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No configuration data was found in the assistant."
+        )
+
+    _send_to_studio(assistant_name, {"config": config_yaml}, studio_cfg)
+
+
+def handle_push_endpoints(args: argparse.Namespace) -> None:
+    """Push only the endpoints configuration (endpoints.yml).
+
+    Args:
+        args: The command line arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    endpoints_yaml = read_file(Path(args.endpoints))
+    if not endpoints_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No endpoints data was found in the assistant."
+        )
+
+    _send_to_studio(assistant_name, {"endpoints": endpoints_yaml}, studio_cfg)

rasa/studio/results_logger.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, Text
 
 import structlog
 from keycloak.exceptions import KeycloakError
@@ -78,6 +78,11 @@ def response_has_errors(response: Dict) -> bool:
     )
 
 
+def response_has_id(response: Dict[Text, Any]) -> bool:
+    response_id = response.get("id")
+    return isinstance(response_id, str) and bool(response_id)
+
+
 def _handle_rasa_exception(e: RasaException) -> StudioResult:
     error_msg = "Rasa internal exception was raised while interacting with Studio."
     structlogger.error("studio.rasa_error", event_info=error_msg, exception=str(e))

rasa/studio/train.py

@@ -34,7 +34,7 @@ def handle_train(args: argparse.Namespace) -> Optional[str]:
     from rasa.api import train as train_all
 
     handler = StudioDataHandler(
-        studio_config=StudioConfig.read_config(), assistant_name=args.assistant_name[0]
+        studio_config=StudioConfig.read_config(), assistant_name=args.assistant_name
     )
     if args.entities or args.intents:
         handler.request_data(args.intents, args.entities)