rasa-pro 3.8.16__py3-none-any.whl

rasa/studio/data_handler.py

@@ -0,0 +1,352 @@
+import base64
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import rasa.shared.utils.cli
+import requests
+from rasa.shared.core.domain import KEY_RESPONSES, KEY_SLOTS, Domain
+from rasa.shared.core.flows.flow import Flow
+from rasa.shared.exceptions import RasaException
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.utils.common import get_temp_dir_name
+
+from rasa.studio.auth import KeycloakToken, KeycloakTokenReader, StudioAuth
+from rasa.studio.config import StudioConfig
+
+logger = logging.getLogger(__name__)
+
+
+class StudioDataHandler:
+    def __init__(
+        self, studio_config: StudioConfig, assistant_name: Optional[str]
+    ) -> None:
+        self.studio_config = studio_config.read_config()
+        if not assistant_name:
+            rasa.shared.utils.cli.print_error_and_exit(
+                "Assistant name not specified please specify"
+                "the assistant name with: 'rasa studio <command> assistant_name'"
+            )
+        self.assistant_name = assistant_name
+
+        self.nlu: Optional[str] = None
+        self.domain: Optional[str] = None
+        self.flows: Optional[str] = None
+
+    def has_flows(self) -> bool:
+        return self.flows is not None
+
+    def has_nlu(self) -> bool:
+        return self.nlu is not None
+
+    def _build_request(
+        self,
+        intent_names: Optional[List[str]] = None,
+        entity_names: Optional[List[str]] = None,
+    ) -> dict:
+        request = {
+            "query": (
+                "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
+                "{ exportAsEncodedYaml(input: $input) "
+                "{ ... on ExportModernAsEncodedYamlOutput "
+                "{ nlu flows domain } "
+                "... on ExportClassicAsEncodedYamlOutput "
+                "{ nlu domain }}}"
+            ),
+            "variables": {"input": {"assistantName": self.assistant_name}},
+        }
+        if intent_names or entity_names:
+            obj = []
+            if intent_names:
+                obj.append(
+                    {
+                        "name": intent_names,
+                        "type": "Intent",
+                    }
+                )
+            if entity_names:
+                obj.append(
+                    {
+                        "name": entity_names,
+                        "type": "Entity",
+                    }
+                )
+            request["variables"]["input"]["objects"] = obj  # type: ignore[index]
+
+        return request
+
+    def _make_request(self, GQL_req: Dict[Any, Any]) -> Dict[Any, Any]:
+        token = KeycloakTokenReader().get_token()
+        if token.is_expired():
+            token = self.refresh_token(token)
+
+        if not self.studio_config.studio_url:
+            return rasa.shared.utils.cli.print_error_and_exit(
+                "No endpoint found in config. Please run `rasa studio config`."
+            )
+
+        res = requests.post(
+            url=self.studio_config.studio_url,
+            json=GQL_req,
+            headers={
+                "Authorization": f"{token.token_type} {token.access_token}",
+                "Content-Type": "application/json",
+            },
+        )
+
+        if res.status_code != 200:
+            raise RasaException(
+                f"Download from Studio with URL: "
+                f"{self.studio_config.studio_url} failed "
+                f"with status code {res.status_code}"
+            )
+
+        res_json = res.json()
+        if self._validate_response(res_json):
+            return res_json
+
+        return rasa.shared.utils.cli.print_error_and_exit(
+            "Failed to download data from Rasa Studio."
+        )
+
+    def refresh_token(self, token: KeycloakToken) -> KeycloakToken:
+        if not token.can_refresh():
+            rasa.shared.utils.cli.print_error_and_exit(
+                "Access token expired and cannot be refreshed. "
+                "Please run `rasa studio login`."
+            )
+        auth = StudioAuth(self.studio_config)
+        auth.refresh_token(token.refresh_token)
+        token = KeycloakTokenReader().get_token()
+        return token
+
+    def request_all_data(self) -> None:
+        """Gets the data from Rasa Studio.
+
+        Returns:
+            The data from Rasa Studio.
+        """
+        GQL_req = self._build_request()
+        response = self._make_request(GQL_req)
+        self._extract_data(response)
+
+    def request_data(
+        self, intent_names: List[str], entity_names: List[str], **kwargs: Any
+    ) -> None:
+        """Gets the data from Rasa Studio.
+
+        Args:
+            intent_names: List of intents to download
+            entity_names: List of entities to download
+            **kwargs: Additional arguments to pass to the request
+
+        Returns:
+            The data from Rasa Studio.
+        """
+        GQL_req = self._build_request(intent_names, entity_names)
+        response = self._make_request(GQL_req)
+        self._extract_data(response)
+
+    def _validate_response(self, response: dict) -> bool:
+        """Validates the response from Rasa Studio.
+
+        Args:
+            response: The response from Rasa Studio.
+
+        Returns:
+            True if the response is valid, False otherwise.
+        """
+        try:
+            if not response.get("data"):
+                for error in response["errors"]:
+                    logger.error(error["message"])
+                return False
+            if not response["data"]["exportAsEncodedYaml"]:
+                logger.error(response["data"])
+                return False
+            if not (
+                response["data"]["exportAsEncodedYaml"].get("nlu")
+                or response["data"]["exportAsEncodedYaml"].get("flows")
+            ):
+                logger.error(
+                    "No nlu or flows data in Studio response."
+                    "Cannot determine assistant type."
+                )
+                return False
+        except KeyError:
+            return False
+        return True
+
+    def _extract_data(self, response: dict) -> None:
+        return_data = response["data"]["exportAsEncodedYaml"]
+
+        self.nlu = self._decode_response(return_data.get("nlu"))
+        self.domain = self._decode_response(return_data.get("domain"))
+        self.flows = self._decode_response(return_data.get("flows"))
+
+        if not self.has_nlu() and not self.has_flows():
+            raise RasaException("No nlu or flows data in Studio response.")
+
+    @staticmethod
+    def _decode_response(data: str) -> Optional[str]:
+        if not data:
+            return None
+        return base64.b64decode(data).decode("utf-8")
+
+
+class DataDiffGenerator:
+    """Generate diff between original and studio data."""
+
+    def __init__(
+        self,
+        original_domain: Optional[Dict] = None,
+        studio_domain: Optional[Dict] = None,
+        original_nlu: Optional[Dict[str, List]] = None,
+        studio_nlu: Optional[Dict[str, List]] = None,
+        original_flows: Optional[List[Flow]] = None,
+        studio_flows: Optional[List[Flow]] = None,
+    ):
+        self.original_domain = original_domain
+        self.studio_domain = studio_domain
+        self.original_nlu = original_nlu
+        self.studio_nlu = studio_nlu
+        self.original_flows = original_flows
+        self.studio_flows = studio_flows
+
+    def create_new_domain_from_diff(self) -> Dict:
+        """Create a new domain file from the diff."""
+        if self.studio_domain is None or self.original_domain is None:
+            return {}
+        return self._domain_from_diff_rec(self.studio_domain, self.original_domain)
+
+    @staticmethod
+    def _domain_from_diff_rec(studio: Dict, original: Dict) -> Dict:
+        ret_dict = {}
+        for key in studio:
+            if key not in original:
+                ret_dict[key] = studio[key]
+            elif isinstance(studio[key], dict):
+                ret_dict[key] = DataDiffGenerator._domain_from_diff_rec(
+                    studio[key], original[key]
+                )
+                # remove empty diffs
+                if not ret_dict[key]:
+                    del ret_dict[key]
+                elif key not in [KEY_SLOTS, KEY_RESPONSES]:
+                    # copy over the whole key not just the diff in case of items
+                    # to get complete (valid) data not just the diff
+                    ret_dict[key] = studio[key]
+            elif isinstance(studio[key], list):
+                ret_dict[key] = []
+                for item in studio[key]:
+                    if item not in original[key]:
+                        ret_dict[key].append(item)
+
+                # if list is empty, remove it
+                if not ret_dict[key]:
+                    del ret_dict[key]
+
+        return ret_dict
+
+    def create_new_nlu_from_diff(self) -> Dict:
+        """Create a new nlu file from the diff."""
+        if self.studio_nlu is None or self.original_nlu is None:
+            return {"nlu": []}
+
+        nlu_diff = []
+        nlu_new_examples = [
+            new for new in self.studio_nlu["nlu"] if new not in self.original_nlu["nlu"]
+        ]
+        if nlu_new_examples:
+            for new_example in nlu_new_examples:
+                nlu_diff.append(new_example)
+                intent = new_example.get("intent")
+                if intent:
+                    self._diff_nlu_examples(new_example, nlu_diff, "intent", intent)
+                synonym = new_example.get("synonym")
+                if synonym:
+                    self._diff_nlu_examples(new_example, nlu_diff, "synonym", synonym)
+
+        return {"nlu": nlu_diff}
+
+    def create_new_flows_from_diff(self) -> List[Flow]:
+        """Create a new flows file from the diff."""
+        if self.studio_flows is None or self.original_flows is None:
+            return []
+
+        flows_new = [new for new in self.studio_flows if new not in self.original_flows]
+        return flows_new
+
+    def _diff_nlu_examples(
+        self, new_example: Dict, nlu_diff: List, match_key: str, match_value: str
+    ) -> None:
+        """Creates diff of nlu data examples.
+
+        Args:
+            new_example (Dict): intent or synonym with examples
+            nlu_diff (List): list of diff examples
+            match_key (str): intent or synonym name
+            match_value (str): intent or synonym value
+        """
+        orig = list(
+            filter(
+                lambda x: x.get(match_key) == match_value,
+                self.original_nlu["nlu"],  # type: ignore[index]
+            )
+        )
+        if len(orig) == 1:
+            orig_ex = orig[0]["examples"].split("\n")
+            new_ex = new_example["examples"].split("\n")
+            new_example["examples"] = "\n".join(
+                list(set(new_ex).difference(set(orig_ex)))
+            )
+            if not new_example["examples"]:
+                nlu_diff.remove(new_example)
+
+
+def import_data_from_studio(
+    handler: StudioDataHandler, domain_path: Path, data_paths: List[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
+
+    Returns:
+        Tuple[TrainingDataImporter, TrainingDataImporter]:
+        data from studio and original data
+    """
+    tmp_dir = get_temp_dir_name()
+    data_original = TrainingDataImporter.load_from_dict(
+        domain_path=domain_path, training_data_paths=data_paths
+    )
+
+    data_paths = []
+
+    if handler.has_nlu():
+        nlu_file = Path(tmp_dir, "nlu.yml")
+        write_yaml(read_yaml(handler.nlu), nlu_file)
+        data_paths.append(str(nlu_file))
+
+    if handler.has_flows():
+        flows_file = Path(tmp_dir, "flows.yml")
+        write_yaml(read_yaml(handler.flows), flows_file)
+        data_paths.append(str(flows_file))
+
+    if not data_paths:
+        return rasa.shared.utils.cli.print_error_and_exit(
+            "No Data for nlu or flows. Can't import data from Studio."
+        )
+
+    studio_domain = Domain.from_yaml(handler.domain)
+    domain_file = Path(tmp_dir, "domain.yml")
+    studio_domain.persist(domain_file)
+
+    data_from_studio = TrainingDataImporter.load_from_dict(
+        domain_path=str(domain_file), training_data_paths=data_paths
+    )
+
+    return data_from_studio, data_original

rasa/studio/download.py

@@ -0,0 +1,350 @@
+import argparse
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    DEFAULT_DATA_PATH,
+    DEFAULT_DOMAIN_PATHS,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.flows.yaml_flows_io import YamlFlowsWriter
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.yaml import read_yaml
+
+from rasa.studio.config import StudioConfig
+from rasa.studio.constants import (
+    STUDIO_DOMAIN_FILENAME,
+    STUDIO_FLOWS_FILENAME,
+    STUDIO_NLU_FILENAME,
+)
+from rasa.studio.data_handler import (
+    DataDiffGenerator,
+    StudioDataHandler,
+    import_data_from_studio,
+)
+from rasa.utils.mapper import RasaPrimitiveStorageMapper
+
+logger = logging.getLogger(__name__)
+
+
+def handle_download(args: argparse.Namespace) -> None:
+    handler = StudioDataHandler(
+        studio_config=StudioConfig.read_config(), assistant_name=args.assistant_name[0]
+    )
+    handler.request_all_data()
+    domain_path = rasa.cli.utils.get_validated_path(
+        args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
+    )
+    domain_path = Path(domain_path)
+
+    data_paths = [
+        Path(
+            rasa.cli.utils.get_validated_path(
+                f, "data", DEFAULT_DATA_PATH, none_is_valid=False
+            )
+        )
+        for f in args.data
+    ]
+
+    if not args.overwrite:
+        _handle_download_no_overwrite(
+            handler=handler,
+            domain_path=domain_path,
+            data_paths=data_paths,
+        )
+    else:
+        _handle_download_with_overwrite(
+            handler=handler,
+            domain_path=domain_path,
+            data_paths=data_paths,
+        )
+
+
+def _handle_download_no_overwrite(
+    handler: StudioDataHandler,
+    domain_path: Path,
+    data_paths: List[Path],
+) -> None:
+    data_from_studio, data_original = import_data_from_studio(
+        handler, domain_path, data_paths
+    )
+
+    if domain_path.is_dir():
+        studio_domain_path = domain_path / STUDIO_DOMAIN_FILENAME
+        diff_eng = DataDiffGenerator(
+            original_domain=data_original.get_domain().as_dict(),
+            studio_domain=data_from_studio.get_domain().as_dict(),
+        )
+        new_domain_data = diff_eng.create_new_domain_from_diff()
+        studio_domain = Domain.from_dict(new_domain_data)
+        if not studio_domain.is_empty():
+            studio_domain.persist(studio_domain_path)
+        else:
+            logger.warning("No additional domain data found.")
+    elif domain_path.is_file():
+        domain_merged = data_original.get_domain().merge(data_from_studio.get_domain())
+        domain_merged.persist(domain_path)
+
+    if len(data_paths) == 1 and data_paths[0].is_file():
+        data_path = data_paths[0]
+        if handler.has_nlu():
+            data_nlu = data_original.get_nlu_data().merge(
+                data_from_studio.get_nlu_data()
+            )
+            data_nlu.persist_nlu(data_path)
+        if handler.has_flows():
+            data_flows = data_original.get_flows().merge(data_from_studio.get_flows())
+            YamlFlowsWriter.dump(data_flows.underlying_flows, data_path)
+
+    elif len(data_paths) == 1 and data_paths[0].is_dir():
+        if handler.has_nlu():
+            data_path = data_paths[0] / Path(STUDIO_NLU_FILENAME)
+            _persist_nlu_diff(data_original, data_from_studio, data_path)
+        if handler.has_flows():
+            data_path = data_paths[0] / Path(STUDIO_FLOWS_FILENAME)
+            _persist_flows_diff(data_original, data_from_studio, data_path)
+    else:
+        if data_paths[0].is_dir():
+            logger.info(f"Saving data to {data_paths[0]}.")
+            data_path = data_paths[0] / Path(STUDIO_NLU_FILENAME)
+        else:
+            logger.info(f"Saving data to {STUDIO_NLU_FILENAME}.")
+            data_path = Path(STUDIO_NLU_FILENAME)
+        if handler.has_nlu():
+            _persist_nlu_diff(data_original, data_from_studio, data_path)
+        if handler.has_flows():
+            _persist_flows_diff(data_original, data_from_studio, data_path)
+
+
+def _persist_nlu_diff(
+    data_original: TrainingDataImporter,
+    data_from_studio: TrainingDataImporter,
+    data_path: Path,
+) -> None:
+    """Creates a new nlu file from the diff of original and studio data."""
+    diff_eng = DataDiffGenerator(
+        original_nlu=read_yaml(data_original.get_nlu_data().nlu_as_yaml()),
+        studio_nlu=read_yaml(data_from_studio.get_nlu_data().nlu_as_yaml()),
+    )
+    new_nlu_data = diff_eng.create_new_nlu_from_diff()
+    if new_nlu_data["nlu"]:
+        pretty_write_nlu_yaml(new_nlu_data, data_path)
+    else:
+        logger.warning("No additional nlu data found.")
+
+
+def _persist_flows_diff(
+    data_original: TrainingDataImporter,
+    data_from_studio: TrainingDataImporter,
+    data_path: Path,
+) -> None:
+    """Creates a new flows file from the diff of original and studio data."""
+    diff_eng = DataDiffGenerator(
+        original_flows=data_original.get_flows().underlying_flows,
+        studio_flows=data_from_studio.get_flows().underlying_flows,
+    )
+    new_flows_data = diff_eng.create_new_flows_from_diff()
+    if new_flows_data:
+        YamlFlowsWriter.dump(new_flows_data, data_path)
+    else:
+        logger.warning("No additional flows data found.")
+
+
+def pretty_write_nlu_yaml(data: Dict, file: Path) -> None:
+    """Writes the nlu yaml in a pretty way.
+
+    Args:
+        data: The data to write.
+        file: The file to write to.
+    """
+    from ruamel import yaml
+    from ruamel.yaml.scalarstring import LiteralScalarString
+
+    dumper = yaml.YAML()
+    for item in data["nlu"]:
+        if item.get("examples"):
+            item["examples"] = LiteralScalarString(item["examples"])
+
+    with file.open("w", encoding="utf-8") as outfile:
+        dumper.dump(data, outfile)
+
+
+def _handle_download_with_overwrite(
+    handler: StudioDataHandler,
+    domain_path: Path,
+    data_paths: List[Path],
+) -> None:
+    data_from_studio, data_original = import_data_from_studio(
+        handler, domain_path, data_paths
+    )
+    mapper = RasaPrimitiveStorageMapper(
+        domain_path=domain_path, training_data_paths=data_paths
+    )
+    if domain_path.is_file():
+        domain_merged = data_from_studio.get_domain().merge(data_original.get_domain())
+        domain_merged.persist(domain_path)
+    elif domain_path.is_dir():
+        default = domain_path / Path(STUDIO_DOMAIN_FILENAME)
+        studio_domain = data_from_studio.get_domain()
+
+        paths = get_domain_path(domain_path, data_from_studio, mapper)
+
+        _persist_domain_part(
+            {"intents": studio_domain.as_dict().get("intents", [])},
+            default,
+            paths["intent_path"],
+        )
+        _persist_domain_part(
+            {"entities": studio_domain.as_dict().get("entities", [])},
+            default,
+            paths["entities_path"],
+        )
+        _persist_domain_part(
+            {"actions": studio_domain.as_dict().get("actions", [])},
+            default,
+            paths["action_path"],
+        )
+        _persist_domain_part(
+            {"slots": studio_domain.as_dict().get("slots", {})},
+            default,
+            paths["slot_path"],
+        )
+        _persist_domain_part(
+            {"responses": studio_domain.as_dict().get("responses", {})},
+            default,
+            paths["response_path"],
+        )
+
+    if len(data_paths) == 1 and data_paths[0].is_file():
+        if handler.has_nlu():
+            nlu_data_merged = data_from_studio.get_nlu_data().merge(
+                data_original.get_nlu_data()
+            )
+            nlu_data_merged.persist_nlu(data_paths[0])
+        if handler.has_flows():
+            flows_data_merged = data_from_studio.get_flows().merge(
+                data_original.get_flows()
+            )
+            YamlFlowsWriter.dump(flows_data_merged.underlying_flows, data_paths[0])
+    elif len(data_paths) == 1 and data_paths[0].is_dir():
+        data_path = data_paths[0]
+        paths = get_training_path(data_path, data_original, mapper)
+        if handler.has_nlu():
+            nlu_data = data_from_studio.get_nlu_data()
+            if paths["nlu_path"].exists():
+                nlu_file = TrainingDataImporter.load_from_dict(
+                    training_data_paths=[str(paths["nlu_path"])]
+                )
+                nlu_data = nlu_data.merge(nlu_file.get_nlu_data())
+            pretty_write_nlu_yaml(read_yaml(nlu_data.nlu_as_yaml()), paths["nlu_path"])
+        if handler.has_flows():
+            flows_data = data_from_studio.get_flows()
+            if paths["flow_path"].exists():
+                flows_file = TrainingDataImporter.load_from_dict(
+                    training_data_paths=[str(paths["flow_path"])]
+                )
+                flows_data = flows_data.merge(flows_file.get_flows())
+            YamlFlowsWriter.dump(flows_data.underlying_flows, paths["flow_path"])
+    else:
+        #  TODO: we are not handling the case of multiple data paths?
+        raise NotImplementedError("Multiple data paths are not supported yet.")
+
+
+def _persist_domain_part(
+    domain_part: Dict[str, Any], default: Path, path: Optional[Path]
+) -> None:
+    domain = Domain.from_dict(domain_part)
+    if (path is not None) and path.exists():
+        domain = Domain.from_file(path).merge(domain, override=True)
+        domain.persist(path)
+    else:
+        domain.persist(default)
+
+
+def get_training_path(
+    path: Path,
+    data_original: TrainingDataImporter,
+    mapper: RasaPrimitiveStorageMapper,
+) -> Dict[str, Path]:
+    nlu_paths = set()
+    flow_paths = set()
+    for intent in data_original.get_nlu_data().intents:
+        for path in mapper.get_file(intent, "intents").get("training", []):
+            nlu_paths.add(path)
+    flows = [flow.id for flow in data_original.get_flows().underlying_flows]
+    for flow in flows:
+        for path in mapper.get_file(flow, "flows").get("training", []):
+            flow_paths.add(path)
+
+    return {
+        "nlu_path": _select_path(nlu_paths, "nlu", path, STUDIO_NLU_FILENAME),
+        "flow_path": _select_path(flow_paths, "flows", path, STUDIO_FLOWS_FILENAME),
+    }
+
+
+def get_domain_path(
+    domain_path: Path,
+    data_from_studio: TrainingDataImporter,
+    mapper: RasaPrimitiveStorageMapper,
+) -> Dict[str, Path]:
+    intent_paths = set()
+    entities_paths = set()
+    slot_paths = set()
+    action_paths = set()
+    response_paths = set()
+    # nlu-based
+    for intent in data_from_studio.get_domain().intents:
+        for path in mapper.get_file(intent, "intents").get("domain", []):
+            intent_paths.add(path)
+    for entity in data_from_studio.get_domain().entities:
+        for path in mapper.get_file(entity, "entities").get("domain", []):
+            entities_paths.add(path)
+    # flow-based
+    slot_list = [slot.name for slot in data_from_studio.get_domain().slots]
+    for slot in slot_list:
+        for path in mapper.get_file(slot, "slots").get("domain", []):
+            slot_paths.add(path)
+    for action in data_from_studio.get_domain().action_names_or_texts:
+        for path in mapper.get_file(action, "actions").get("domain", []):
+            action_paths.add(path)
+    for response in data_from_studio.get_domain().responses:
+        for path in mapper.get_file(response, "responses").get("domain", []):
+            response_paths.add(path)
+
+    return {
+        "intent_path": _select_path(
+            intent_paths, "intents", domain_path, STUDIO_DOMAIN_FILENAME
+        ),
+        "entities_path": _select_path(
+            entities_paths, "entities", domain_path, STUDIO_DOMAIN_FILENAME
+        ),
+        "slot_path": _select_path(
+            slot_paths, "slots", domain_path, STUDIO_DOMAIN_FILENAME
+        ),
+        "action_path": _select_path(
+            action_paths, "actions", domain_path, STUDIO_DOMAIN_FILENAME
+        ),
+        "response_path": _select_path(
+            response_paths, "responses", domain_path, STUDIO_DOMAIN_FILENAME
+        ),
+    }
+
+
+def _select_path(
+    paths: Set[Path], primitive_type: str, default_path: Path, default: str
+) -> Path:
+    if len(paths) == 1:
+        path = paths.pop()
+    elif len(paths) > 1:
+        path = paths.pop()
+        logger.warning(
+            f"Saving {primitive_type} to {path}."
+            f"Please keep Studio related {primitive_type} in a single file."
+        )
+    else:  # no path in paths
+        path = default_path / Path(default)
+        logger.info(f"Saving {primitive_type} to {path}.")
+    return path