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

rasa/shared/utils/yaml.py

@@ -21,6 +21,7 @@ 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 ruamel.yaml.scalarstring import LiteralScalarString
 
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
@@ -794,6 +795,25 @@ def write_yaml(
         should_preserve_key_order: Whether to force preserve key order in `data`.
         transform: A function to transform the data before writing it to the file.
     """
+
+    def multiline_str_representer(self: Any, value: str) -> Any:
+        """Dump multi-line strings as readable YAML block scalars where possible."""
+        if "\n" in value:
+            # First line after the newline decides: paragraph vs. snippet
+            first_line = value.split("\n", 1)[1]
+
+            # If the first line after the newline is not indented, treat the value
+            # as plain text. Indented text is likely pre-formatted YAML/JSON/etc.
+            if not first_line.startswith((" ", "\t")):
+                return self.represent_scalar(
+                    "tag:yaml.org,2002:str",
+                    LiteralScalarString(value),
+                    style="|",
+                )
+
+        # Fallback: keep default YAML scalar style (plain/quoted)
+        return self.represent_scalar("tag:yaml.org,2002:str", value)
+
     _enable_ordered_dict_yaml_dumping()
 
     if should_preserve_key_order:
@@ -808,6 +828,7 @@ def write_yaml(
         type(None),
         lambda self, _: self.represent_scalar("tag:yaml.org,2002:null", "null"),
     )
+    dumper.representer.add_representer(str, multiline_str_representer)
 
     if isinstance(target, StringIO):
         dumper.dump(data, target, transform=transform)
@@ -1025,6 +1046,17 @@ def validate_yaml_with_jsonschema(
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(underlying_yaml_exception=e)
 
+    validate_data_with_jsonschema(source_data, schema_content, humanize_error)
+
+
+def validate_data_with_jsonschema(
+    source_data: Any,
+    schema_content: Any,
+    humanize_error: Callable[
+        [jsonschema.ValidationError], str
+    ] = default_error_humanizer,
+) -> None:
+    """Validate Python object against the provided jsonschema content."""
     try:
         jsonschema.validate(source_data, schema_content)
     except jsonschema.ValidationError as error:

rasa/studio/data_handler.py

@@ -320,14 +320,14 @@ def create_new_flows_from_diff(
 
 
 def import_data_from_studio(
-    handler: StudioDataHandler, domain_path: Path, data_paths: List[Path]
+    handler: StudioDataHandler, domain_path: Path, data_path: Path
 ) -> Tuple[TrainingDataImporter, TrainingDataImporter]:
     """Construct TrainingDataImporter from Studio data and original data.
 
     Args:
         handler (StudioDataHandler): handler with data from studio
         domain_path (Path): Path to a domain file
-        data_paths (List[Path]): List of paths to training data files
+        data_path (List[Path]): List of paths to training data files
 
     Returns:
         Tuple[TrainingDataImporter, TrainingDataImporter]:
@@ -335,7 +335,7 @@ def import_data_from_studio(
     """
     tmp_dir = get_temp_dir_name()
     data_original = TrainingDataImporter.load_from_dict(
-        domain_path=domain_path, training_data_paths=data_paths
+        domain_path=str(domain_path), training_data_paths=[str(data_path)]
     )
 
     data_paths = []

rasa/studio/download/download.py

@@ -1,6 +1,6 @@
 import argparse
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, Optional, Tuple
 
 import questionary
 import structlog
@@ -46,7 +46,7 @@ def handle_download(args: argparse.Namespace) -> None:
     )
     handler.request_all_data()
 
-    domain_path, data_paths = _prepare_data_and_domain_paths(args)
+    domain_path, data_path = _prepare_data_and_domain_paths(args)
 
     # Handle config and endpoints.
     config_path, write_config = _handle_file_overwrite(
@@ -78,12 +78,12 @@ def handle_download(args: argparse.Namespace) -> None:
         structlogger.info("studio.download.config_endpoints", event_info=message)
 
     if not args.overwrite:
-        _handle_download_no_overwrite(handler, domain_path, data_paths)
+        _handle_download_no_overwrite(handler, domain_path, data_path)
     else:
-        _handle_download_with_overwrite(handler, domain_path, data_paths)
+        _handle_download_with_overwrite(handler, domain_path, data_path)
 
 
-def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, List[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:
@@ -115,28 +115,15 @@ def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, List
             domain_path = domain_path / STUDIO_DOMAIN_FILENAME
             domain_path.touch()
 
-    # Prepare data paths.
-    data_paths: List[Path] = []
-    for f in args.data:
-        data_path = rasa.cli.utils.get_validated_path(
-            f, "data", DEFAULT_DATA_PATH, none_is_valid=True
-        )
-
-        if data_path is None:
-            data_path = Path(f)
-            data_path.mkdir(parents=True, exist_ok=True)
-        else:
-            data_path = Path(data_path)
+    data_path = rasa.cli.utils.get_validated_path(
+        args.data[0], "data", DEFAULT_DATA_PATH, none_is_valid=True
+    )
 
-        if data_path.is_file() or data_path.is_dir():
-            data_paths.append(data_path)
-        else:
-            data_path.mkdir(parents=True, exist_ok=True)
-            data_paths.append(data_path)
+    data_path = Path(data_path or args.data[0])
+    if not (data_path.is_file() or data_path.is_dir()):
+        data_path.mkdir(parents=True, exist_ok=True)
 
-    # Remove duplicates while preserving order.
-    data_paths = list(dict.fromkeys(data_paths))
-    return domain_path, data_paths
+    return domain_path, data_path
 
 
 def _handle_file_overwrite(
@@ -177,7 +164,7 @@ def _handle_file_overwrite(
 
 
 def _handle_download_no_overwrite(
-    handler: StudioDataHandler, domain_path: Path, data_paths: List[Path]
+    handler: StudioDataHandler, domain_path: Path, data_path: Path
 ) -> None:
     """Handles downloading without overwriting existing files.
 
@@ -187,10 +174,10 @@ def _handle_download_no_overwrite(
         data_paths: The paths to the data files or directories.
     """
     data_from_studio, data_local = import_data_from_studio(
-        handler, domain_path, data_paths
+        handler, domain_path, data_path
     )
     _merge_domain_no_overwrite(domain_path, data_from_studio, data_local)
-    _merge_data_no_overwrite(data_paths, handler, data_from_studio, data_local)
+    _merge_data_no_overwrite(data_path, handler, data_from_studio, data_local)
 
 
 def _merge_domain_no_overwrite(
@@ -264,7 +251,7 @@ def _merge_file_domain(
 
 
 def _merge_data_no_overwrite(
-    data_paths: List[Path],
+    data_path: Path,
     handler: StudioDataHandler,
     data_from_studio: TrainingDataImporter,
     data_local: TrainingDataImporter,
@@ -272,38 +259,29 @@ def _merge_data_no_overwrite(
     """Merges NLU and flow data without overwriting existing data.
 
     Args:
-        data_paths: The paths to the data files or directories.
+        data_path: The paths to the data files or directories.
         handler: The StudioDataHandler instance.
         data_from_studio: The Studio data importer.
         data_local: The local data importer.
     """
-    if not data_paths:
+    if not data_path:
         structlogger.warning(
             "studio.download.merge_data_no_overwrite.no_path",
             event_info="No data paths provided. Skipping data merge.",
         )
         return
 
-    if len(data_paths) == 1:
-        data_path = data_paths[0]
-        if data_path.is_file():
-            _merge_file_data_no_overwrite(
-                data_path, handler, data_from_studio, data_local
-            )
-        elif data_path.is_dir():
-            _merge_dir_data_no_overwrite(
-                data_path, handler, data_from_studio, data_local
-            )
-        else:
-            structlogger.warning(
-                "studio.download.merge_data_no_overwrite.invalid_path",
-                event_info=(
-                    f"Provided path '{data_path}' is neither a file nor a directory."
-                ),
-            )
+    if data_path.is_file():
+        _merge_file_data_no_overwrite(data_path, handler, data_from_studio, data_local)
+    elif data_path.is_dir():
+        _merge_dir_data_no_overwrite(data_path, handler, data_from_studio, data_local)
     else:
-        # TODO: Handle multiple data paths.
-        raise NotImplementedError("Multiple data paths are not supported yet.")
+        structlogger.warning(
+            "studio.download.merge_data_no_overwrite.invalid_path",
+            event_info=(
+                f"Provided path '{data_path}' is neither a file nor a directory."
+            ),
+        )
 
 
 def _merge_file_data_no_overwrite(
@@ -353,25 +331,23 @@ def _merge_dir_data_no_overwrite(
 
 
 def _handle_download_with_overwrite(
-    handler: StudioDataHandler, domain_path: Path, data_paths: List[Path]
+    handler: StudioDataHandler, domain_path: Path, data_path: Path
 ) -> None:
     """Handles downloading and merging data when the user opts for overwrite.
 
     Args:
         handler: The StudioDataHandler instance.
         domain_path: The path to the domain file or directory.
-        data_paths: The paths to the data files or directories.
+        data_path: The paths to the data files or directories.
     """
     data_from_studio, data_local = import_data_from_studio(
-        handler, domain_path, data_paths
+        handler, domain_path, data_path
     )
     mapper = RasaPrimitiveStorageMapper(
-        domain_path=domain_path, training_data_paths=data_paths
+        domain_path=domain_path, training_data_paths=[data_path]
     )
     merge_domain_with_overwrite(data_from_studio, data_local, domain_path)
-    merge_flows_with_overwrite(
-        data_paths, handler, data_from_studio, data_local, mapper
-    )
+    merge_flows_with_overwrite(data_path, handler, data_from_studio, data_local, mapper)
 
 
 def _persist_nlu_diff(
@@ -432,8 +408,9 @@ def pretty_write_nlu_yaml(data: Dict, file: Path) -> None:
         file: The file to write to.
     """
     dumper = yaml.YAML()
-    for item in data["nlu"]:
-        if item.get("examples"):
-            item["examples"] = LiteralScalarString(item["examples"])
+    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/download/flows.py

@@ -18,7 +18,7 @@ STUDIO_FLOWS_DIR_NAME = "studio_flows"
 
 
 def merge_flows_with_overwrite(
-    data_paths: List[Path],
+    data_path: Path,
     handler: Any,
     data_from_studio: TrainingDataImporter,
     data_local: TrainingDataImporter,
@@ -28,17 +28,12 @@ def merge_flows_with_overwrite(
     Merges flows data from a file or directory when overwrite is enabled.
 
     Args:
-        data_paths: List of paths to the training data.
+        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 len(data_paths) != 1:
-        # TODO: Handle multiple data paths.
-        raise NotImplementedError("Multiple data paths are not supported yet.")
-
-    data_path = data_paths[0]
     if data_path.is_file():
         merge_training_data_file(handler, data_from_studio, data_local, data_path)
     elif data_path.is_dir():
@@ -132,7 +127,8 @@ def merge_nlu_in_directory(
         )
         nlu_data = nlu_data.merge(local_nlu.get_nlu_data())
 
-    pretty_write_nlu_yaml(read_yaml(nlu_data.nlu_as_yaml()), nlu_file_path)
+    if nlu_yaml := nlu_data.nlu_as_yaml():
+        pretty_write_nlu_yaml(read_yaml(nlu_yaml), nlu_file_path)
 
 
 def get_nlu_path(
@@ -211,14 +207,16 @@ def merge_flows_in_directory(
     local_flow_paths: Set[Path] = _get_local_flow_paths(local_flows, mapper)
 
     # Track updated flows and update local files with Studio flow data.
-    all_updated_flows: List[Flow] = []
+    all_updated_flows_ids: List[Text] = []
     for flow_file_path in local_flow_paths:
-        updated_file_flows = _update_flow_file(flow_file_path, studio_flow_map)
-        all_updated_flows.extend(updated_file_flows)
+        updated_flows_ids = _update_flow_file(flow_file_path, studio_flow_map)
+        all_updated_flows_ids.extend(updated_flows_ids)
 
     # Identify new Studio flows and save them as separate files in the directory.
     new_flows = [
-        flow for flow in studio_flow_map.values() if flow not in all_updated_flows
+        flow
+        for flow_id, flow in studio_flow_map.items()
+        if flow_id not in all_updated_flows_ids
     ]
     _dump_flows_as_separate_files(new_flows, data_path)
 
@@ -243,7 +241,7 @@ def _get_local_flow_paths(
 
 def _update_flow_file(
     flow_file_path: Path, studio_flows_map: Dict[Text, Any]
-) -> List[Flow]:
+) -> List[Text]:
     """
     Reads a flow file, updates outdated flows, and replaces them with studio versions.
 
@@ -252,31 +250,25 @@ def _update_flow_file(
         studio_flows_map: A dictionary mapping flow IDs to their updated versions.
 
     Returns:
-        A list of flows from the updated flow file.
+        A list of Flows IDs from the updated flow file.
     """
     file_flows = YAMLFlowsReader.read_from_file(flow_file_path, False)
-    updated_list: List[Any] = []
-    has_changes = False
-
-    for flow in file_flows.underlying_flows:
-        studio_flow = studio_flows_map.get(flow.id)
-        if studio_flow is not None and studio_flow != flow:
-            updated_list.append(studio_flow)
-            has_changes = True
-        else:
-            updated_list.append(flow)
-
-    if has_changes:
-        new_flows_list = FlowsList(underlying_flows=updated_list)
-        new_flows_list = strip_default_next_references(new_flows_list)
+
+    # Build a list of flows, replacing any outdated flow with its studio version
+    updated_flows = [
+        studio_flows_map.get(flow.id, flow) or flow
+        for flow in file_flows.underlying_flows
+    ]
+
+    # If the updated flows differ from the original file flows, write them back
+    if updated_flows != file_flows.underlying_flows:
         YamlFlowsWriter.dump(
-            flows=new_flows_list.underlying_flows,
+            flows=updated_flows,
             filename=flow_file_path,
             should_clean_json=True,
         )
-        return new_flows_list.underlying_flows
 
-    return file_flows.underlying_flows
+    return [flow.id for flow in updated_flows]
 
 
 def _dump_flows_as_separate_files(flows: List[Any], data_path: Path) -> None:

rasa/studio/link.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import argparse
+import datetime
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Text, Union
+
+import questionary
+import structlog
+from pydantic import BaseModel, Field
+
+import rasa.shared.utils.cli
+from rasa.constants import RASA_DIR_NAME
+from rasa.shared.utils.yaml import read_yaml_file, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.upload import (
+    check_if_assistant_already_exists,
+    handle_upload,
+    is_auth_working,
+)
+
+structlogger = structlog.get_logger(__name__)
+
+_LINK_FILE_NAME: Text = "studio.yml"
+
+
+class AssistantLinkPayload(BaseModel):
+    assistant_name: Text
+    studio_url: Text
+    linked_at: Text = Field(
+        default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z"
+    )
+
+
+def _link_file(project_root: Path) -> Path:
+    """Return `<project-root>/.rasa/studio.yml`.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The path to the link file.
+    """
+    return project_root / RASA_DIR_NAME / _LINK_FILE_NAME
+
+
+def _write_link_file(
+    project_root: Path, assistant_name: Text, studio_url: Text
+) -> None:
+    """Persist assistant information inside the project.
+
+    Args:
+        project_root: The path to the project root.
+        assistant_name: The name of the assistant.
+        studio_url: The URL of the Rasa Studio instance.
+    """
+    file_path = _link_file(project_root)
+    file_path.parent.mkdir(exist_ok=True, parents=True)
+
+    payload = AssistantLinkPayload(
+        assistant_name=assistant_name,
+        studio_url=studio_url,
+    )
+    write_yaml(payload.model_dump(), file_path)
+
+
+def _read_link_file(
+    project_root: Path = Path.cwd(),
+) -> Optional[Union[List[Any], Dict[Text, Any]]]:
+    """Reads the link configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant information if the file exists, otherwise None.
+    """
+    file_path = _link_file(project_root)
+    if not file_path.is_file():
+        return None
+
+    return read_yaml_file(file_path)
+
+
+def read_assistant_name(project_root: Path = Path.cwd()) -> Optional[Text]:
+    """Reads the assistant_name from the linked configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant name if the file exists, otherwise None.
+    """
+    linked = _read_link_file(project_root)
+    assistant_name = (
+        linked.get("assistant_name") if linked and isinstance(linked, dict) else None
+    )
+
+    if not assistant_name:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "This project is not linked to any Rasa Studio assistant.\n"
+            "Run `rasa studio link <assistant-name>` first."
+        )
+
+    return assistant_name
+
+
+def get_studio_config() -> StudioConfig:
+    """Get the StudioConfig object or exit with an error message.
+
+    Returns:
+        A valid StudioConfig object.
+    """
+    config = StudioConfig.read_config()
+    if not config.is_valid():
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Rasa Studio is not configured correctly. Run `rasa studio config` first."
+        )
+    if not is_auth_working(config.studio_url, not config.disable_verify):
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Authentication invalid or expired. Please run `rasa studio login`."
+        )
+    return config
+
+
+def _ensure_assistant_exists(
+    assistant_name: Text,
+    studio_cfg: StudioConfig,
+    args: argparse.Namespace,
+) -> bool:
+    """Create the assistant on Studio if it does not yet exist.
+
+    Args:
+        assistant_name: The name the user provided on the CLI.
+        studio_cfg: The validated Studio configuration.
+        args: The original CLI args (needed for `handle_upload`).
+
+    Returns:
+        True if the assistant already exists or was created, False otherwise.
+    """
+    verify_ssl = not studio_cfg.disable_verify
+    assistant_already_exists = check_if_assistant_already_exists(
+        assistant_name, studio_cfg.studio_url, verify_ssl
+    )
+    if not assistant_already_exists:
+        should_create_assistant = questionary.confirm(
+            f"Assistant '{assistant_name}' was not found on Rasa Studio. "
+            f"Do you want to create it?"
+        ).ask()
+        if should_create_assistant:
+            # `handle_upload` expects the name to live in `args.assistant_name`
+            args.assistant_name = assistant_name
+            handle_upload(args)
+
+            rasa.shared.utils.cli.print_info(
+                f"Assistant {assistant_name} successfully created."
+            )
+        return should_create_assistant
+
+    return assistant_already_exists
+
+
+def handle_link(args: argparse.Namespace) -> None:
+    """Implementation of `rasa studio link <assistant-name>` CLI command.
+
+    Args:
+        args: The command line arguments.
+    """
+    assistant_name: Text = args.assistant_name[0]
+    studio_cfg = get_studio_config()
+    assistant_exists = _ensure_assistant_exists(assistant_name, studio_cfg, args)
+    if not assistant_exists:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Project has not been linked with Studio assistant."
+        )
+
+    project_root = Path.cwd()
+    link_file = _link_file(project_root)
+
+    if link_file.exists():
+        overwrite = questionary.confirm(
+            f"This project is already linked " f"(link file '{link_file}').\nOverwrite?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_info(
+                "Existing link kept – nothing was changed."
+            )
+            sys.exit(0)
+
+    _write_link_file(project_root, assistant_name, studio_cfg.studio_url)
+
+    structlogger.info(
+        "studio.link.success",
+        event_info=f"Project linked to Studio assistant '{assistant_name}'.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Project successfully linked to assistant '{assistant_name}'."
+    )

rasa/studio/pull.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Text, Union
+
+import structlog
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import DEFAULT_CONFIG_PATH, DEFAULT_ENDPOINTS_PATH
+from rasa.shared.utils.io import write_text_file
+from rasa.studio.data_handler import StudioDataHandler
+from rasa.studio.download.download import handle_download
+from rasa.studio.link import get_studio_config, read_assistant_name
+
+structlogger = structlog.get_logger(__name__)
+
+
+def _write_to_file(
+    content: Text, file_type: Text, file_path: Text, default_path: Text
+) -> None:
+    """Write the content to a file.
+
+    Args:
+        content: The content to write.
+        file_type: The type of file (e.g., "config" or "endpoints".).
+        file_path: The path to the file.
+        default_path: The default path to use file_path is not valid.
+    """
+    path: Union[Path, str, None] = rasa.cli.utils.get_validated_path(
+        file_path, file_type, default_path, none_is_valid=True
+    )
+    write_text_file(content, path, encoding="utf-8")
+    rasa.shared.utils.cli.print_success(f"Pulled {file_type} data from assistant.")
+
+
+def handle_pull(args: argparse.Namespace) -> None:
+    """Pull all data and overwrite the local assistant.
+
+    Args:
+        args: The parsed arguments.
+    """
+    assistant_name = read_assistant_name()
+
+    # Use the CLI command logic to download with overwrite
+    download_args = argparse.Namespace(**vars(args))
+    download_args.assistant_name = [assistant_name]
+    download_args.overwrite = True
+
+    handle_download(download_args)
+    rasa.shared.utils.cli.print_success("Pulled the data from assistant.")
+
+
+def handle_pull_config(args: argparse.Namespace) -> None:
+    """Pull just the assistant's `config.yml`.
+
+    Args:
+        args: The parsed arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    handler = StudioDataHandler(studio_cfg, assistant_name)
+    handler.request_all_data()
+
+    config_yaml = handler.get_config()
+    if not config_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No configuration data was found in the Studio assistant."
+        )
+
+    _write_to_file(config_yaml, "config", args.config, DEFAULT_CONFIG_PATH)
+
+
+def handle_pull_endpoints(args: argparse.Namespace) -> None:
+    """Pull just the assistant's `endpoints.yml`.
+
+    Args:
+        args: The parsed arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    handler = StudioDataHandler(studio_cfg, assistant_name)
+    handler.request_all_data()
+
+    endpoints_yaml = handler.get_endpoints()
+    if not endpoints_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No endpoints data was found in the Studio assistant."
+        )
+
+    _write_to_file(endpoints_yaml, "endpoints", args.endpoints, DEFAULT_ENDPOINTS_PATH)