rasa-pro 3.13.0.dev20250613__py3-none-any.whl → 3.13.0rc2__py3-none-any.whl

rasa/studio/prompts.py

@@ -0,0 +1,221 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Text
+
+import structlog
+
+from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
+from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_PROMPTS_PATH,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+)
+from rasa.shared.utils.common import all_subclasses
+from rasa.shared.utils.llm import get_system_default_prompts
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+
+structlogger = structlog.get_logger()
+
+CONTEXTUAL_RESPONSE_REPHRASER_NAME = "contextual_response_rephraser"
+COMMAND_GENERATOR_NAME = "command_generator"
+ENTERPRISE_SEARCH_NAME = "enterprise_search"
+
+
+def handle_prompts(prompts: Dict[Text, Text], root: Path) -> None:
+    """Handle prompts for the assistant.
+
+    Args:
+        prompts: A dict containing prompt names as keys and their content as values.
+        root: The root directory where the prompts should be saved.
+    """
+    if not prompts:
+        return
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    config: Dict = read_yaml(config_path)
+    endpoints: Dict = read_yaml(endpoints_path)
+
+    system_prompts = get_system_default_prompts(config, endpoints)
+
+    _handle_contextual_response_rephraser(
+        root,
+        prompts.get(CONTEXTUAL_RESPONSE_REPHRASER_NAME),
+        system_prompts.contextual_response_rephraser,
+        endpoints,
+    )
+    _handle_command_generator(
+        root,
+        prompts.get(COMMAND_GENERATOR_NAME),
+        system_prompts.command_generator,
+        config,
+    )
+    _handle_enterprise_search(
+        root,
+        prompts.get(ENTERPRISE_SEARCH_NAME),
+        system_prompts.enterprise_search,
+        config,
+    )
+
+
+def _handle_contextual_response_rephraser(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    endpoints: Dict,
+) -> None:
+    """Handles the contextual response rephraser prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the contextual response rephraser prompt.
+        system_prompt: The system prompt for comparison.
+        endpoints: The endpoints configuration to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{CONTEXTUAL_RESPONSE_REPHRASER_NAME}.jinja2", prompt_content
+    )
+
+    endpoints["nlg"] = endpoints.get("nlg") or {}
+    endpoints["nlg"]["prompt"] = str(prompt_path)
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    write_yaml(data=endpoints, target=endpoints_path, should_preserve_key_order=True)
+
+
+def _handle_command_generator(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the command generator prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the command generator prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{COMMAND_GENERATOR_NAME}.jinja2", prompt_content
+    )
+
+    command_generator_names: List[str] = [
+        cls.__name__ for cls in all_subclasses(LLMBasedCommandGenerator)
+    ]
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_PIPELINE_KEY,
+        component_names=command_generator_names,
+        prompt_key=PROMPT_TEMPLATE_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _handle_enterprise_search(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the enterprise search prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the enterprise search prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{ENTERPRISE_SEARCH_NAME}.jinja2", prompt_content
+    )
+
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_POLICIES_KEY,
+        component_names=[EnterpriseSearchPolicy.__name__],
+        prompt_key=PROMPT_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _is_custom_prompt(
+    studio_prompt: Optional[Text], system_prompt: Optional[Text]
+) -> bool:
+    """Check if the prompt has been customized in Studio.
+
+    Args:
+        studio_prompt: The prompt content from the Studio.
+        system_prompt: The default system prompt content.
+    """
+    return bool(studio_prompt and studio_prompt != system_prompt)
+
+
+def _save_prompt_file(root: Path, filename: str, content: str) -> Path:
+    """Save a prompt file to the specified root directory.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        filename: The name of the prompt file.
+        content: The content of the prompt.
+    """
+    prompts_dir = root / DEFAULT_PROMPTS_PATH
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    file_path = prompts_dir / filename
+    file_path.write_text(content, encoding="utf-8")
+
+    return file_path.relative_to(root)
+
+
+def _add_prompt_to_config(
+    *,
+    config: Dict,
+    section_key: str,
+    component_names: List[str],
+    prompt_key: str,
+    prompt_path: str,
+) -> None:
+    """Add a prompt path to the specified section of the configuration."""
+    matches = [
+        component
+        for component in config.get(section_key, [])
+        if component.get(CONFIG_NAME_KEY) in component_names
+    ]
+
+    if not matches:
+        return
+
+    # Update the first occurrence of the component.
+    matches[0][prompt_key] = prompt_path
+
+    if len(matches) > 1:
+        structlogger.warning(
+            "rasa.studio.prompts.add_prompt_to_config.multiple_components",
+            event_info=(
+                "Multiple components found in the configuration for the same prompt."
+            ),
+        )

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,

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

@@ -19,6 +19,7 @@ from rasa.studio.upload import (
     make_request,
     run_validation,
 )
+from rasa.studio.utils import validate_argument_paths
 
 structlogger = structlog.get_logger(__name__)
 
@@ -48,6 +49,11 @@ def _send_to_studio(
     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}'.")
 
 
@@ -57,6 +63,7 @@ def handle_push(args: argparse.Namespace) -> None:
     Args:
         args: The command line arguments.
     """
+    validate_argument_paths(args)
     studio_cfg = get_studio_config()
 
     run_validation(args)

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)