rasa-pro 3.8.17__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/studio/data_handler.py

@@ -50,7 +50,7 @@ class StudioDataHandler:
                 "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
                 "{ exportAsEncodedYaml(input: $input) "
                 "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain } "
+                "{ nlu flows domain endpoints config } "
                 "... on ExportClassicAsEncodedYamlOutput "
                 "{ nlu domain }}}"
             ),
@@ -148,6 +148,12 @@ class StudioDataHandler:
         response = self._make_request(GQL_req)
         self._extract_data(response)
 
+    def get_config(self) -> Optional[str]:
+        return self.config
+
+    def get_endpoints(self) -> Optional[str]:
+        return self.endpoints
+
     def _validate_response(self, response: dict) -> bool:
         """Validates the response from Rasa Studio.
 
@@ -184,6 +190,8 @@ class StudioDataHandler:
         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"))
+        self.config = self._decode_response(return_data.get("config"))
+        self.endpoints = self._decode_response(return_data.get("endpoints"))
 
         if not self.has_nlu() and not self.has_flows():
             raise RasaException("No nlu or flows data in Studio response.")
@@ -195,114 +203,113 @@ class StudioDataHandler:
         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]
+def combine_domains(
+    studio_domain: Dict[str, Any], original_domain: Dict[str, Any]
+) -> Dict:
+    """Create a new domain file from the diff."""
+    if studio_domain is None or original_domain is None:
+        return {}
+    return _combine_domain_keys(studio_domain, original_domain)
+
+
+def _combine_domain_keys(
+    first_domain: Dict[str, Any], second_domain: Dict[str, Any]
+) -> Dict[str, Any]:
+    combined_keys = {}
+    for key in first_domain:
+        if key not in second_domain:
+            combined_keys[key] = first_domain[key]
+        elif isinstance(first_domain[key], dict):
+            combined_keys[key] = _combine_domain_keys(
+                first_domain[key], second_domain[key]
             )
+            # remove empty diffs
+            if not combined_keys[key]:
+                del combined_keys[key]
+            elif key not in [KEY_SLOTS, KEY_RESPONSES]:
+                # for all keys except slots and responses, we want to keep the
+                # keys from the first domain
+                combined_keys[key] = first_domain[key]
+        elif isinstance(first_domain[key], list):
+            combined_keys[key] = []
+            for item in first_domain[key]:
+                if item not in second_domain[key]:
+                    combined_keys[key].append(item)
+
+            # if list is empty, remove it
+            if not combined_keys[key]:
+                del combined_keys[key]
+
+    return combined_keys
+
+
+def _diff_nlu_examples(
+    new_example: Dict,
+    nlu_diff: List,
+    match_key: str,
+    match_value: str,
+    original_nlu_examples: List,
+) -> 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
+        original_nlu_examples (List): original nlu examples
+    """
+    orig = list(
+        filter(
+            lambda x: x.get(match_key) == match_value,
+            original_nlu_examples,
         )
-        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)
+    )
+    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 create_new_nlu_from_diff(
+    studio_nlu: Dict[str, Any], original_nlu: Dict[str, Any]
+) -> Dict:
+    """Create a new nlu file from the diff."""
+    # `or []` handles the case where the data contains the property as an empty
+    # key, example yaml:
+    # ```
+    # nlu:
+    # ```
+    # in this case, the yaml parser will return an empty dict (because it
+    # can't know that it is supposed to be a list, so we need to convert it
+    # to a list
+    studio_nlu_data = studio_nlu.get("nlu", []) or []
+    original_nlu_data = original_nlu.get("nlu", []) or []
+
+    nlu_diff = []
+    for new in studio_nlu_data:
+        if new in original_nlu_data:
+            continue
+
+        nlu_diff.append(new)
+        intent = new.get("intent")
+        if intent:
+            _diff_nlu_examples(new, nlu_diff, "intent", intent, original_nlu_data)
+        synonym = new.get("synonym")
+        if synonym:
+            _diff_nlu_examples(new, nlu_diff, "synonym", synonym, original_nlu_data)
+
+    return {"nlu": nlu_diff}
+
+
+def create_new_flows_from_diff(
+    studio_flows: List[Flow], original_flows: List[Flow]
+) -> List[Flow]:
+    """Create a new flows file from the diff."""
+    flows_new = [new for new in studio_flows if new not in original_flows]
+    return flows_new
 
 
 def import_data_from_studio(

rasa/studio/download.py

@@ -1,19 +1,24 @@
 import argparse
 import logging
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import questionary
+import structlog
 
 import rasa.cli.utils
 import rasa.shared.utils.cli
 from rasa.shared.constants import (
     DEFAULT_DATA_PATH,
-    DEFAULT_DOMAIN_PATHS,
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_ENDPOINTS_PATH,
 )
 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 import data_handler
 from rasa.studio.config import StudioConfig
 from rasa.studio.constants import (
     STUDIO_DOMAIN_FILENAME,
@@ -21,13 +26,119 @@ from rasa.studio.constants import (
     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__)
+structlogger = structlog.getLogger(__name__)
+
+
+def _handle_file_overwrite(
+    file_path: Optional[str], default_path: str, file_type: str
+) -> Tuple[Optional[Path], bool]:
+    """Handles the logic for determining whether to
+    overwrite an existing file or create a new one.
+    Works for config and endpoints at this moment
+
+    Args:
+        file_path (Optional[str]): The path to the file
+                    provided by the user. Can be None.
+        default_path (str): The default path to use if `file_path`
+                    is None or invalid. Must be a file path.
+        file_type (str): The type of the file (e.g., "config",
+            "endpoints") for logging and messaging purposes.
+
+    Returns:
+        tuple[Optional[Path], bool]: A tuple containing the
+                            resolved file path and a boolean
+                        indicating whether to write the file.
+    """
+    file_already_exists = rasa.cli.utils.get_validated_path(
+        file_path, file_type, default_path, none_is_valid=True
+    )
+    write_file = False
+    path = None
+    file_or_default_path = file_path or default_path
+
+    if file_already_exists is None:
+        path = Path(file_or_default_path)
+        if path.is_dir():
+            path = path / default_path
+        return path, True
+
+    if questionary.confirm(
+        f"{file_type.capitalize()} file '{file_or_default_path}' "
+        f"already exists. Do you want to overwrite it?"
+    ).ask():
+        write_file = True
+        path = Path(file_or_default_path)
+    return path, write_file
+
+
+def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, List[Path]]:
+    """Handles the logic for preparing the domain and data paths
+    based on the provided arguments.
+
+    Args:
+        args (argparse.Namespace): The parsed arguments.
+
+    Returns:
+        tuple[Path, list[Path]]: A tuple containing the domain path
+                        and a list of data paths.
+    """
+    # prepare domain
+    domain_path = rasa.cli.utils.get_validated_path(
+        args.domain, "domain", DEFAULT_DOMAIN_PATH, none_is_valid=True
+    )
+    domain_or_default_path = args.domain or DEFAULT_DOMAIN_PATH
+
+    if domain_path is None:
+        # If the path is None, use the provided domain path
+        domain_path = Path(domain_or_default_path)
+        domain_path.touch()
+
+    if isinstance(domain_path, str):
+        domain_path = Path(domain_path)
+
+    if domain_path.is_file():
+        if not args.overwrite:
+            domain_path.unlink()
+            domain_path.touch()
+
+    if domain_path.is_dir():
+        if not args.overwrite:
+            domain_path = domain_path / STUDIO_DOMAIN_FILENAME
+            domain_path.touch()
+
+    # prepare data
+    data_paths = []
+
+    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:
+            # If the path is None, use the default data path
+            data_path = Path(f)
+            data_path.mkdir(parents=True, exist_ok=True)
+        else:
+            data_path = Path(data_path)
+
+        if data_path.is_file() or data_path.is_dir():
+            # If it's a file, add it directly
+            data_paths.append(data_path)
+        else:
+            # If it doesn't exist, create the directory
+            data_path.mkdir(parents=True, exist_ok=True)
+            data_paths.append(data_path)
+
+    # Remove duplicates while preserving order
+    data_paths = list(dict.fromkeys(data_paths))
+
+    return domain_path, data_paths
 
 
 def handle_download(args: argparse.Namespace) -> None:
@@ -35,19 +146,43 @@ def handle_download(args: argparse.Namespace) -> None:
         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, data_paths = _prepare_data_and_domain_paths(args)
+
+    # handle config and endpoints
+    config_path, write_config = _handle_file_overwrite(
+        args.config, DEFAULT_CONFIG_PATH, "config"
+    )
+    endpoints_path, write_endpoints = _handle_file_overwrite(
+        args.endpoints, DEFAULT_ENDPOINTS_PATH, "endpoints"
     )
-    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
-    ]
+    # generate log message if we write the config or endpoints
+    message_parts = []
+
+    config_path = config_path if write_config else None
+    endpoints_path = endpoints_path if write_endpoints else None
+
+    if config_path:
+        config_data = handler.get_config()
+        if not config_data:
+            rasa.shared.utils.cli.print_error_and_exit("No config data found.")
+        with open(config_path, "w") as f:
+            f.write(config_data)
+            message_parts.append(f"config to '{config_path}'")
+
+    if endpoints_path:
+        endpoints_data = handler.get_endpoints()
+        if not endpoints_data:
+            raise ValueError("No endpoints data found.")
+
+        with open(endpoints_path, "w") as f:
+            f.write(endpoints_data)
+            message_parts.append(f"endpoints to '{endpoints_path}'")
+
+    if message_parts:
+        message = "Downloaded " + " and ".join(message_parts)
+        structlogger.info("studio.download.config_endpoints", event_info=message)
 
     if not args.overwrite:
         _handle_download_no_overwrite(
@@ -74,11 +209,10 @@ def _handle_download_no_overwrite(
 
     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 = data_handler.combine_domains(
+            data_from_studio.get_domain().as_dict(),
+            data_original.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)
@@ -125,11 +259,10 @@ def _persist_nlu_diff(
     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 = data_handler.create_new_nlu_from_diff(
+        read_yaml(data_from_studio.get_nlu_data().nlu_as_yaml()),
+        read_yaml(data_original.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:
@@ -142,11 +275,10 @@ def _persist_flows_diff(
     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 = data_handler.create_new_flows_from_diff(
+        data_from_studio.get_flows().underlying_flows,
+        data_original.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:
@@ -183,6 +315,7 @@ def _handle_download_with_overwrite(
     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)

rasa/studio/results_logger.py

@@ -0,0 +1,137 @@
+from dataclasses import dataclass
+from functools import wraps
+from typing import Callable, Any, Dict
+
+import structlog
+from keycloak.exceptions import KeycloakError
+from requests.exceptions import RequestException, Timeout, ConnectionError
+
+from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.cli import print_success, print_error
+from rasa.studio.config import StudioConfig
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class StudioResult:
+    message: str
+    was_successful: bool
+
+    @staticmethod
+    def success(message: str) -> "StudioResult":
+        return StudioResult(message, was_successful=True)
+
+    @staticmethod
+    def error(response: Dict[str, Any]) -> "StudioResult":
+        """Create a StudioResult from a GraphQL error response.
+
+        Factory will evaluate the response and return a StudioResult with the
+        appropriate message and success status.
+        """
+        if isinstance(response.get("errors"), list):
+            error_details = "; ".join(
+                [error.get("message", "Unknown error") for error in response["errors"]]
+            )
+        else:
+            error_details = "No detailed error information available."
+
+        structlogger.warn(
+            "studio.graphql_error", event_info=error_details, response=response
+        )
+        return StudioResult(error_details, was_successful=False)
+
+
+def with_studio_error_handler(
+    func: Callable[..., StudioResult],
+) -> Callable[..., StudioResult]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            result = func(*args, **kwargs)
+            if result.was_successful:
+                print_success(result.message)
+            else:
+                print_error(result.message)
+            return result
+        except RasaException as e:
+            return _handle_rasa_exception(e)
+        except KeycloakError as e:
+            return _handle_keycloak_error(e)
+        except ConnectionError as e:
+            return _handle_connection_error(e)
+        except Timeout as e:
+            return _handle_timeout_error(e)
+        except RequestException as e:
+            return _handle_request_exception(e)
+        except Exception as e:
+            return _handle_unexpected_error(e)
+
+    return wrapper
+
+
+def response_has_errors(response: Dict) -> bool:
+    return (
+        "errors" in response
+        and isinstance(response["errors"], list)
+        and len(response["errors"]) > 0
+    )
+
+
+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))
+    return StudioResult(message=str(e), was_successful=False)
+
+
+def _handle_keycloak_error(e: KeycloakError) -> StudioResult:
+    error_msg = (
+        f"Unable to authenticate with Keycloak at "
+        f"{StudioConfig.read_config().authentication_server_url} "
+    )
+    if e.response_code == 401:
+        error_msg += "Please check if the credentials are correct."
+    elif e.error_message.startswith("Can't connect to server"):
+        error_msg += (
+            "Please check if the server is running "
+            "and the configured URL is correct. \n"
+            "You may need to reconfigure Rasa Studio "
+            "using 'rasa studio config'."
+        )
+    else:
+        error_msg += f"Error message: {e.error_message}"
+    structlogger.error("studio.keycloak_error", event_info=error_msg, exception=str(e))
+    return StudioResult(error_msg, was_successful=False)
+
+
+def _handle_connection_error(e: ConnectionError) -> StudioResult:
+    studio_url = StudioConfig.read_config().studio_url
+    error_msg = (
+        f"Unable to reach Rasa Studio API at {studio_url} \n"
+        "Please check if Studio is running and the configured URL is correct. \n"
+        "You may need to reconfigure Rasa Studio using 'rasa studio config'."
+    )
+    structlogger.error("studio.graphql_error", event_info=error_msg, exception=str(e))
+    return StudioResult(error_msg, was_successful=False)
+
+
+def _handle_timeout_error(e: Timeout) -> StudioResult:
+    error_msg = "The request timed out. Please try again later."
+    structlogger.error("studio.graphql_timeout", event_info=error_msg, exception=str(e))
+    return StudioResult(error_msg, was_successful=False)
+
+
+def _handle_request_exception(e: RequestException) -> StudioResult:
+    error_msg = f"An error occurred while communicating with the server: {e!s}"
+    structlogger.error(
+        "studio.graphql.request_exception", event_info=error_msg, exception=str(e)
+    )
+    return StudioResult(error_msg, was_successful=False)
+
+
+def _handle_unexpected_error(e: Exception) -> StudioResult:
+    error_msg = f"An unexpected error occurred: {e!s}"
+    structlogger.exception(
+        "studio.unexpected_error", event_info=error_msg, exception=str(e)
+    )
+    return StudioResult(error_msg, was_successful=False)

rasa/studio/train.py

@@ -19,11 +19,11 @@ from rasa.shared.constants import (
 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, write_yaml
+from rasa.studio import data_handler
 from rasa.utils.common import get_temp_dir_name
 
 from rasa.studio.config import StudioConfig
 from rasa.studio.data_handler import (
-    DataDiffGenerator,
     StudioDataHandler,
     import_data_from_studio,
 )
@@ -50,9 +50,9 @@ def handle_train(args: argparse.Namespace) -> Optional[str]:
         handler, domain, args.data
     )
 
-    domain = data_original.get_domain().merge(data_form_studio.get_domain())  # type: ignore[assignment]  # noqa: E501
+    domain = data_original.get_domain().merge(data_form_studio.get_domain())  # type: ignore[assignment]
 
-    domain_file = _create_temp_file(read_yaml(domain.as_yaml()), "domain.yml")  # type: ignore[union-attr]  # noqa: E501
+    domain_file = _create_temp_file(read_yaml(domain.as_yaml()), "domain.yml")  # type: ignore[union-attr]
 
     studio_training_files = make_training_files(
         handler, data_form_studio, data_original
@@ -116,11 +116,10 @@ def make_training_files(
         training_files.append(training_file)
 
     if handler.has_flows():
-        diff = DataDiffGenerator(
-            original_flows=data_original.get_flows().underlying_flows,
-            studio_flows=data_form_studio.get_flows().underlying_flows,
+        diff_flows = data_handler.create_new_flows_from_diff(
+            data_form_studio.get_flows().underlying_flows,
+            data_original.get_flows().underlying_flows,
         )
-        diff_flows = diff.create_new_flows_from_diff()
         tmp_dir = get_temp_dir_name()
         training_file = Path(tmp_dir, "flows.yml")
         YamlFlowsWriter.dump(diff_flows, training_file)