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

rasa/shared/utils/llm.py

@@ -1,13 +1,17 @@
+from __future__ import annotations
+
 import importlib.resources
 import json
 import logging
 from copy import deepcopy
+from datetime import datetime
 from functools import wraps
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
+    List,
     Literal,
     Optional,
     Text,
@@ -18,15 +22,23 @@ from typing import (
 )
 
 import structlog
+from pydantic import BaseModel, Field
 
 import rasa.shared.utils.io
-from rasa.core.utils import AvailableEndpoints
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
     DEFAULT_PROMPT_PACKAGE_NAME,
+    LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
     MODELS_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
@@ -61,9 +73,11 @@ from rasa.shared.providers.mappings import (
     get_embedding_client_from_provider,
     get_llm_client_from_provider,
 )
+from rasa.shared.utils.common import all_subclasses
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 
 if TYPE_CHECKING:
+    from rasa.core.agent import Agent
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -73,13 +87,15 @@ USER = "USER"
 
 AI = "AI"
 
-DEFAULT_OPENAI_GENERATE_MODEL_NAME = "gpt-3.5-turbo"
+DEFAULT_OPENAI_GENERATE_MODEL_NAME = "gpt-4o-2024-11-20"
+
+DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-4o-2024-11-20"
 
-DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-3.5-turbo"
+DEFAULT_ENTERPRISE_SEARCH_POLICY_MODEL_NAME = "gpt-4.1-mini-2025-04-14"
 
 DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED = "gpt-4-0613"
 
-DEFAULT_OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-ada-002"
+DEFAULT_OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-3-large"
 
 DEFAULT_OPENAI_TEMPERATURE = 0.7
 
@@ -107,6 +123,18 @@ _CombineConfigs_F = TypeVar(
 )
 
 
+class SystemPrompts(BaseModel):
+    command_generator: str = Field(
+        ..., description="Prompt used by the LLM command generator."
+    )
+    enterprise_search: str = Field(
+        ..., description="Prompt for standard enterprise search requests."
+    )
+    contextual_response_rephraser: str = Field(
+        ..., description="Prompt used for re-phrasing assistant responses."
+    )
+
+
 def _compute_hash_for_cache_from_configs(
     config_x: Dict[str, Any], config_y: Dict[str, Any]
 ) -> int:
@@ -191,6 +219,7 @@ def tracker_as_readable_transcript(
     human_prefix: str = USER,
     ai_prefix: str = AI,
     max_turns: Optional[int] = 20,
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
 ) -> str:
     """Creates a readable dialogue from a tracker.
 
@@ -199,6 +228,7 @@ def tracker_as_readable_transcript(
         human_prefix: the prefix to use for human utterances
         ai_prefix: the prefix to use for ai utterances
         max_turns: the maximum number of turns to include in the transcript
+        turns_wrapper: optional function to wrap the turns in a custom way
 
     Example:
         >>> tracker = Tracker(
@@ -235,8 +265,11 @@ def tracker_as_readable_transcript(
         elif isinstance(event, BotUttered):
             transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")
 
-    if max_turns:
-        transcript = transcript[-max_turns:]
+    # turns_wrapper to count multiple utterances by bot/user as single turn
+    if turns_wrapper:
+        transcript = turns_wrapper(transcript)
+    # otherwise, just take the last `max_turns` lines of the transcript
+    transcript = transcript[-max_turns if max_turns is not None else None :]
 
     return "\n".join(transcript)
 
@@ -678,7 +711,6 @@ def get_prompt_template(
     Returns:
         The prompt template.
     """
-
     try:
         if jinja_file_path is not None:
             prompt_template = rasa.shared.utils.io.read_file(jinja_file_path)
@@ -814,7 +846,9 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
 
 
 def resolve_model_client_config(
-    model_config: Optional[Dict[str, Any]], component_name: Optional[str] = None
+    model_config: Optional[Dict[str, Any]],
+    component_name: Optional[str] = None,
+    model_groups: Optional[List[Dict[str, Any]]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Resolve the model group in the model config.
 
@@ -828,6 +862,7 @@ def resolve_model_client_config(
         model_config: The model config to be resolved.
         component_name: The name of the component.
         component_name: The method of the component.
+        model_groups: Model groups from endpoints.yml.
 
     Returns:
         The resolved llm config.
@@ -854,7 +889,12 @@ def resolve_model_client_config(
 
     model_group_id = model_config.get(MODEL_GROUP_CONFIG_KEY)
 
-    endpoints = AvailableEndpoints.get_instance()
+    # If `model_groups` is provided, use it to initialise `AvailableEndpoints`,
+    # since `get_instance()` reads from the local endpoints file instead.
+    if model_groups:
+        endpoints = AvailableEndpoints(model_groups=model_groups)
+    else:
+        endpoints = AvailableEndpoints.get_instance()
     if endpoints.model_groups is None:
         _raise_invalid_config_exception(
             reason=(
@@ -886,3 +926,149 @@ def resolve_model_client_config(
         )
 
     return model_group[0]
+
+
+def generate_sender_id(test_case_name: str) -> str:
+    # add timestamp suffix to ensure sender_id is unique
+    return f"{test_case_name}_{datetime.now()}"
+
+
+async def create_tracker_for_user_step(
+    step_sender_id: str,
+    agent: "Agent",
+    test_case_tracker: "DialogueStateTracker",
+    index_user_uttered_event: int,
+) -> None:
+    """Creates a tracker for the user step."""
+    tracker = test_case_tracker.copy()
+    # modify the sender id so that the original tracker is not overwritten
+    tracker.sender_id = step_sender_id
+
+    if tracker.events:
+        # get the timestamp of the event just before the user uttered event
+        timestamp = tracker.events[index_user_uttered_event - 1].timestamp
+        # revert the tracker to the event just before the user uttered event
+        tracker = tracker.travel_back_in_time(timestamp)
+
+    # store the tracker with the unique sender id
+    await agent.tracker_store.save(tracker)
+
+
+def check_prompt_config_keys_and_warn_if_deprecated(
+    config: dict, component_source: str
+) -> None:
+    """Checks and warns about deprecated config parameters."""
+    if PROMPT_CONFIG_KEY in config and PROMPT_TEMPLATE_CONFIG_KEY in config:
+        structlogger.warning(
+            f"{component_source}.init"
+            ".both_deprecated_and_non_deprecated_config_keys_used_at_the_same_time",
+            event_info=(
+                f"Both '{PROMPT_CONFIG_KEY}' and '{PROMPT_TEMPLATE_CONFIG_KEY}' "
+                f"are present in the config. '{PROMPT_CONFIG_KEY}' will be ignored "
+                f"in favor of {PROMPT_TEMPLATE_CONFIG_KEY}."
+            ),
+        )
+
+    # 'prompt' config key is deprecated in favor of 'prompt_template'
+    if PROMPT_CONFIG_KEY in config:
+        structlogger.warning(
+            f"{component_source}.init.deprecated_config_key",
+            event_info=(
+                f"The config parameter '{PROMPT_CONFIG_KEY}' is deprecated "
+                "and will be removed in Rasa 4.0.0. "
+                f"Please use the config parameter '{PROMPT_TEMPLATE_CONFIG_KEY}'"
+                f" instead. "
+            ),
+        )
+
+
+def _get_llm_command_generator_config(
+    config: Dict[Text, Any],
+) -> Optional[Dict[Text, Any]]:
+    """Get the llm command generator config from config.yml.
+
+    Args:
+        config: The config.yml file data.
+
+    Returns:
+        The llm command generator config.
+    """
+    from rasa.dialogue_understanding.generator import LLMBasedCommandGenerator
+
+    # Collect all LLM based Command Generator class names.
+    command_generator_subclasses = all_subclasses(LLMBasedCommandGenerator)
+    command_generator_class_names = [
+        command_generator.__name__ for command_generator in command_generator_subclasses
+    ]
+
+    # Read the LLM config of the Command Generator from the config.yml file.
+    pipelines = config.get(CONFIG_PIPELINE_KEY, [])
+    for pipeline in pipelines:
+        if pipeline.get(CONFIG_NAME_KEY) in command_generator_class_names:
+            return pipeline.get(LLM_CONFIG_KEY)
+
+    return None
+
+
+def _get_command_generator_prompt(
+    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+) -> Text:
+    """Get the command generator prompt based on the config."""
+    from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
+        DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        MODEL_PROMPT_MAPPER,
+    )
+
+    model_config = _get_llm_command_generator_config(config)
+    llm_config = resolve_model_client_config(
+        model_config=model_config,
+        model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
+    )
+    return get_default_prompt_template_based_on_model(
+        llm_config=llm_config or {},
+        model_prompt_mapping=MODEL_PROMPT_MAPPER,
+        default_prompt_path=DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        fallback_prompt_path=FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+    )
+
+
+def _get_enterprise_search_prompt(config: Dict[Text, Any]) -> Text:
+    """Get the enterprise search prompt based on the config."""
+    from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+
+    def get_enterprise_search_config() -> Dict[Text, Any]:
+        policies = config.get(CONFIG_POLICIES_KEY, [])
+        for policy in policies:
+            if policy.get(CONFIG_NAME_KEY) == EnterpriseSearchPolicy.__name__:
+                return policy
+
+        return {}
+
+    enterprise_search_config = get_enterprise_search_config()
+    return EnterpriseSearchPolicy.get_system_default_prompt_based_on_config(
+        enterprise_search_config
+    )
+
+
+def get_system_default_prompts(
+    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+) -> SystemPrompts:
+    """Returns the system default prompts for the component.
+
+    Args:
+        config: The config.yml file data.
+        endpoints: The endpoints.yml file data.
+
+    Returns:
+        SystemPrompts: A Pydantic model containing all default prompts.
+    """
+    from rasa.core.nlg.contextual_response_rephraser import (
+        DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+    )
+
+    return SystemPrompts(
+        command_generator=_get_command_generator_prompt(config, endpoints),
+        enterprise_search=_get_enterprise_search_prompt(config),
+        contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+    )

rasa/shared/utils/pykwalify_extensions.py

@@ -8,11 +8,6 @@ from typing import Any, Dict, List, Text, Union
 
 from pykwalify.errors import SchemaError
 
-from rasa.shared.utils.constants import (
-    RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
-)
-from rasa.utils.beta import ensure_beta_feature_is_enabled
-
 
 def require_response_keys(
     responses: List[Dict[Text, Any]], _: Dict, __: Text
@@ -31,10 +26,6 @@ def require_response_keys(
 
         conditions = response.get("condition", [])
         if isinstance(conditions, str):
-            ensure_beta_feature_is_enabled(
-                "predicates in response conditions",
-                RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
-            )
             continue
 
         for condition in conditions:

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/constants.py

@@ -14,6 +14,7 @@ RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV = "RASA_STUDIO_CLI_DISABLE_VERIFY_KEY"
 
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"
+DOMAIN_FILENAME = "domain.yml"
 STUDIO_FLOWS_FILENAME = "studio_flows.yml"
 STUDIO_CONFIG_FILENAME = "studio_config.yml"
 STUDIO_ENDPOINTS_FILENAME = "studio_endpoints.yml"

rasa/studio/data_handler.py

@@ -1,4 +1,5 @@
 import base64
+import json
 import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -50,7 +51,7 @@ class StudioDataHandler:
                 "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
                 "{ exportAsEncodedYaml(input: $input) "
                 "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain endpoints config } "
+                "{ nlu flows domain endpoints config prompts } "
                 "... on ExportClassicAsEncodedYamlOutput "
                 "{ nlu domain }}}"
             ),
@@ -161,6 +162,9 @@ class StudioDataHandler:
     def get_endpoints(self) -> Optional[str]:
         return self.endpoints
 
+    def get_prompts(self) -> Optional[dict]:
+        return self.prompts
+
     def _validate_response(self, response: dict) -> bool:
         """Validates the response from Rasa Studio.
 
@@ -200,6 +204,9 @@ class StudioDataHandler:
         self.config = self._decode_response(return_data.get("config"))
         self.endpoints = self._decode_response(return_data.get("endpoints"))
 
+        prompts_string = self._decode_response(return_data.get("prompts"))
+        self.prompts = json.loads(prompts_string) if prompts_string else None
+
         if not self.has_nlu() and not self.has_flows():
             raise RasaException("No nlu or flows data in Studio response.")
 
@@ -320,14 +327,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 +342,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.py

@@ -0,0 +1,167 @@
+import argparse
+import shutil
+from pathlib import Path
+from typing import Dict
+
+import questionary
+import structlog
+from ruamel import yaml
+from ruamel.yaml.scalarstring import LiteralScalarString
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.shared.core.flows.yaml_flows_io import FlowsList
+from rasa.shared.nlu.training_data.training_data import (
+    DEFAULT_TRAINING_DATA_OUTPUT_PATH,
+)
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.constants import DOMAIN_FILENAME
+from rasa.studio.data_handler import StudioDataHandler
+from rasa.studio.prompts import handle_prompts
+from rasa.studio.pull.data import _dump_flows_as_separate_files
+
+structlogger = structlog.get_logger()
+
+
+def handle_download(args: argparse.Namespace) -> None:
+    """Download an assistant from Studio and store it in `<assistant_name>/`.
+
+    Args:
+        args: The command line arguments.
+    """
+    assistant_name = args.assistant_name
+    target_root = _prepare_target_directory(assistant_name)
+
+    handler = StudioDataHandler(
+        studio_config=StudioConfig.read_config(), assistant_name=assistant_name
+    )
+    handler.request_all_data()
+
+    _handle_config(handler, target_root)
+    _handle_endpoints(handler, target_root)
+    _handle_domain(handler, target_root)
+    _handle_data(handler, target_root)
+    handle_prompts(handler, target_root)
+
+    structlogger.info(
+        "studio.download.success",
+        event_info=f"Downloaded assistant '{assistant_name}' from Studio.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Downloaded assistant '{assistant_name}' from Studio."
+    )
+
+
+def _prepare_target_directory(assistant_name: str) -> Path:
+    """Create (or overwrite) the directory where everything is stored.
+
+    Args:
+        assistant_name: The name of the assistant to download.
+
+    Returns:
+        The path to the target directory where the assistant will be stored.
+    """
+    target_root = Path(assistant_name)
+
+    if target_root.exists():
+        overwrite = questionary.confirm(
+            f"Directory '{assistant_name}' already exists. Overwrite it?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_error_and_exit("Download cancelled.")
+
+        shutil.rmtree(target_root)
+
+    target_root.mkdir(parents=True, exist_ok=True)
+    return target_root
+
+
+def _handle_config(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s config file.
+
+    Args:
+        handler: The data handler to retrieve the config from.
+        root: The root directory where the config file will be stored.
+    """
+    config_data = handler.get_config()
+    if not config_data:
+        rasa.shared.utils.cli.print_error_and_exit("No config data found.")
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    config_path.write_text(config_data, encoding="utf-8")
+
+
+def _handle_endpoints(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s endpoints file.
+
+    Args:
+        handler: The data handler to retrieve the endpoints from.
+        root: The root directory where the endpoints file will be stored.
+    """
+    endpoints_data = handler.get_endpoints()
+    if not endpoints_data:
+        rasa.shared.utils.cli.print_error_and_exit("No endpoints data found.")
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    endpoints_path.write_text(endpoints_data, encoding="utf-8")
+
+
+def _handle_domain(handler: StudioDataHandler, root: Path) -> None:
+    """Persist the assistant’s domain file.
+
+    Args:
+        handler: The data handler to retrieve the domain from.
+        root: The root directory where the domain file will be stored.
+    """
+    domain_yaml = handler.domain
+    data = read_yaml(domain_yaml)
+    target = root / DOMAIN_FILENAME
+    write_yaml(
+        data=data,
+        target=target,
+        should_preserve_key_order=True,
+    )
+
+
+def _handle_data(handler: StudioDataHandler, root: Path) -> None:
+    """Persist NLU data and flows.
+
+    Args:
+        handler: The data handler to retrieve the NLU data and flows from.
+        root: The root directory where the NLU data and flows will be stored.
+    """
+    data_path = root / DEFAULT_DATA_PATH
+    data_path.mkdir(parents=True, exist_ok=True)
+
+    if handler.has_nlu():
+        nlu_yaml = handler.nlu
+        nlu_data = read_yaml(nlu_yaml)
+        if nlu_data.get("nlu"):
+            pretty_write_nlu_yaml(
+                nlu_data, data_path / DEFAULT_TRAINING_DATA_OUTPUT_PATH
+            )
+
+    if handler.has_flows():
+        flows_yaml = handler.flows
+        data = read_yaml(flows_yaml)
+        flows_data = data.get("flows", {})
+        flows_list = FlowsList.from_json(flows_data)
+        _dump_flows_as_separate_files(flows_list.underlying_flows, data_path)
+
+
+def pretty_write_nlu_yaml(data: Dict, file: Path) -> None:
+    """Writes the NLU YAML in a pretty way."""
+    dumper = yaml.YAML()
+    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)