rasa-pro 3.13.0.dev3__py3-none-any.whl → 3.13.0.dev5__py3-none-any.whl

rasa/shared/core/flows/steps/no_operation.py

@@ -34,17 +34,20 @@ class NoOperationFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the NoOperationFlowStep object
 
         Returns:
             the NoOperationFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["noop"] = self.noop
-        return data
+        return super().as_json(step_properties={"noop": self.noop})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return "noop"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.noop == other.noop and super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/set_slots.py

@@ -35,17 +35,21 @@ class SetSlotsFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the SetSlotsFlowStep object
 
         Returns:
             the SetSlotsFlowStep object as serialized data
         """
-        data = super().as_json()
-        data["set_slots"] = [{slot["key"]: slot["value"]} for slot in self.slots]
-        return data
+        set_slots = [{slot["key"]: slot["value"]} for slot in self.slots]
+        return super().as_json(step_properties={"set_slots": set_slots})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return "set_slots"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.slots == other.slots and super().__eq__(other)
+        return False

rasa/shared/core/flows/yaml_flows_io.py

@@ -8,8 +8,15 @@ from ruamel import yaml as yaml
 import rasa.shared
 import rasa.shared.data
 import rasa.shared.utils.io
-from rasa.shared.core.flows.flow import Flow
+from rasa.shared.core.flows.flow import DEFAULT_RUN_PATTERN_COMPLETED, Flow
+from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.flows.steps import CollectInformationFlowStep
+from rasa.shared.core.flows.steps.collect import (
+    DEFAULT_ASK_BEFORE_FILLING,
+    DEFAULT_FORCE_SLOT_FILLING,
+    DEFAULT_RESET_AFTER_FLOW_ENDS,
+)
 from rasa.shared.exceptions import RasaException, YamlException
 from rasa.shared.utils.yaml import (
     dump_obj_as_yaml_to_string,
@@ -242,31 +249,43 @@ class YamlFlowsWriter:
     """Class that writes flows information in YAML format."""
 
     @staticmethod
-    def dumps(flows: List[Flow]) -> Text:
+    def dumps(
+        flows: List[Flow],
+        should_clean_json: bool = False,
+    ) -> Text:
         """Dump `Flow`s to YAML.
 
         Args:
             flows: The `Flow`s to dump.
+            should_clean_json: Flag whether to clean the flow JSON.
 
         Returns:
             The dumped YAML.
         """
         dump = {}
         for flow in flows:
-            dumped_flow = flow.as_json()
+            dumped_flow = get_flow_as_json(flow, should_clean_json)
             del dumped_flow["id"]
             dump[flow.id] = dumped_flow
         return dump_obj_as_yaml_to_string({KEY_FLOWS: dump})
 
     @staticmethod
-    def dump(flows: List[Flow], filename: Union[Text, Path]) -> None:
+    def dump(
+        flows: List[Flow],
+        filename: Union[Text, Path],
+        should_clean_json: bool = False,
+    ) -> None:
         """Dump `Flow`s to YAML file.
 
         Args:
             flows: The `Flow`s to dump.
             filename: The path to the file to write to.
+            should_clean_json: Flag whether to clean the flow JSON.
         """
-        rasa.shared.utils.io.write_text_file(YamlFlowsWriter.dumps(flows), filename)
+        rasa.shared.utils.io.write_text_file(
+            YamlFlowsWriter.dumps(flows, should_clean_json),
+            filename,
+        )
 
 
 def is_flows_file(file_path: Union[Text, Path]) -> bool:
@@ -403,3 +422,85 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
     )
 
     return yaml_content
+
+
+def get_flow_as_json(flow: Flow, should_clean_json: bool = False) -> Dict[str, Any]:
+    """
+    Clean the Flow JSON by removing default values and empty fields.
+
+    Args:
+        flow: The Flow object to clean.
+        should_clean_json: Flag indicating whether to clean the JSON.
+
+    Returns:
+        The cleaned Flow JSON as a dictionary.
+    """
+    step_id_to_default_id = {}
+    flow_data = flow.as_json()
+    if not should_clean_json:
+        return flow_data
+
+    def gather_step_ids(step: FlowStep) -> None:
+        """Create a map of step IDs to their default IDs."""
+        step_id_to_default_id[step.id] = step.default_id
+        for link in step.next.links:
+            for child in link.child_steps():
+                gather_step_ids(child)
+
+    def clean_flow_data(data: Dict[str, Any]) -> None:
+        """Remove or omit flow-level fields if they match defaults."""
+        for top_level_step in flow.step_sequence.steps:
+            gather_step_ids(top_level_step)
+
+        if data.get("run_pattern_completed") == DEFAULT_RUN_PATTERN_COMPLETED:
+            data.pop("run_pattern_completed", None)
+
+        if not data.get("persisted_slots"):
+            data.pop("persisted_slots", None)
+
+        _remove_keys_recursively(data, ["metadata"])
+
+        data.pop("file_path", None)
+
+        steps = data.get("steps", [])
+        for i, current_step in enumerate(steps):
+            # Look ahead to the next step if we should remove the 'next' field
+            next_step_data = steps[i + 1] if i + 1 < len(steps) else None
+            clean_step(current_step, next_step_data)
+
+    def clean_step(current_step: Dict[str, Any], next_step: Dict[str, Any]) -> None:
+        """Remove default fields from a step."""
+        # Remove 'next' if it exactly matches the next step's default ID
+        if next_step:
+            next_id = next_step.get("id")
+            default_id = step_id_to_default_id.get(next_id)
+            if next_id and current_step.get("next") == default_id:
+                current_step.pop("next", None)
+
+        # Remove 'id' if it equals its own default
+        step_id = current_step.get("id")
+        if step_id and step_id == step_id_to_default_id.get(step_id):
+            current_step.pop("id", None)
+
+        if "collect" in current_step:
+            clean_collect_step(current_step)
+
+    def clean_collect_step(step_data: Dict[str, Any]) -> None:
+        """Remove default fields from a collect step."""
+        slot_name = step_data["collect"]
+        default_utter = CollectInformationFlowStep._default_utter(slot_name)
+
+        if step_data.get("utter") == default_utter:
+            step_data.pop("utter", None)
+        if step_data.get("ask_before_filling") is DEFAULT_ASK_BEFORE_FILLING:
+            step_data.pop("ask_before_filling", None)
+        if step_data.get("reset_after_flow_ends") is DEFAULT_RESET_AFTER_FLOW_ENDS:
+            step_data.pop("reset_after_flow_ends", None)
+        if step_data.get("force_slot_filling") is DEFAULT_FORCE_SLOT_FILLING:
+            step_data.pop("force_slot_filling", None)
+        if not step_data.get("rejections"):
+            step_data.pop("rejections", None)
+
+    clean_flow_data(flow_data)
+
+    return flow_data

rasa/shared/importers/importer.py

@@ -18,6 +18,7 @@ import importlib_resources
 
 import rasa.shared.constants
 import rasa.shared.core.constants
+import rasa.shared.data
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.constants import CONFIG_ADDITIONAL_LANGUAGES_KEY, CONFIG_LANGUAGE_KEY
@@ -279,6 +280,13 @@ class TrainingDataImporter(ABC):
         """
         raise NotImplementedError
 
+    @staticmethod
+    def get_domain_files(
+        data_paths: Optional[Union[List[Text], Text]] = None,
+    ) -> List[Text]:
+        """Returns the domain file path (see parent class for full docstring)."""
+        return rasa.shared.data.get_data_files(data_paths, Domain.is_domain_file)
+
 
 class NluDataImporter(TrainingDataImporter):
     """Importer that skips any Core-related file reading."""

rasa/shared/providers/_utils.py

@@ -1,7 +1,11 @@
+from typing import Any, Dict, Optional
+
 import structlog
 from litellm import validate_environment
 
 from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_ENV_VAR,
     AWS_REGION_NAME_CONFIG_KEY,
@@ -10,6 +14,9 @@ from rasa.shared.constants import (
     AWS_SECRET_ACCESS_KEY_ENV_VAR,
     AWS_SESSION_TOKEN_CONFIG_KEY,
     AWS_SESSION_TOKEN_ENV_VAR,
+    AZURE_API_BASE_ENV_VAR,
+    AZURE_API_VERSION_ENV_VAR,
+    DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers.embedding._base_litellm_embedding_client import (
@@ -77,3 +84,79 @@ def validate_aws_setup_for_litellm_clients(
             missing_environment_variables=missing_environment_variables,
         )
         raise ProviderClientValidationError(event_info)
+
+
+def validate_azure_client_setup(
+    api_base: Optional[str],
+    api_version: Optional[str],
+    deployment: Optional[str],
+) -> None:
+    """Validates the Azure setup for LiteLLM Router clients to ensure
+     that all required configuration parameters are set.
+    Raises:
+        ProviderClientValidationError: If any required Azure configurations
+            is missing.
+    """
+
+    def generate_event_info_for_missing_setting(
+        setting: str,
+        setting_env_var: Optional[str] = None,
+        setting_config_key: Optional[str] = None,
+    ) -> str:
+        """Generate a part of the message with instructions on what to set
+        for the missing client setting.
+        """
+        info = "Set {setting} with {options}. "
+        options = ""
+        if setting_env_var is not None:
+            options += f"environment variable '{setting_env_var}'"
+        if setting_config_key is not None and setting_env_var is not None:
+            options += " or "
+        if setting_config_key is not None:
+            options += f"config key '{setting_config_key}'"
+
+        return info.format(setting=setting, options=options)
+
+    # All required settings for Azure OpenAI client
+    settings: Dict[str, Dict[str, Any]] = {
+        "API Base": {
+            "current_value": api_base,
+            "env_var": AZURE_API_BASE_ENV_VAR,
+            "config_key": API_BASE_CONFIG_KEY,
+        },
+        "API Version": {
+            "current_value": api_version,
+            "env_var": AZURE_API_VERSION_ENV_VAR,
+            "config_key": API_VERSION_CONFIG_KEY,
+        },
+        "Deployment Name": {
+            "current_value": deployment,
+            "env_var": None,
+            "config_key": DEPLOYMENT_CONFIG_KEY,
+        },
+    }
+
+    missing_settings = [
+        setting_name
+        for setting_name, setting_info in settings.items()
+        if setting_info["current_value"] is None
+    ]
+
+    if missing_settings:
+        event_info = f"Client settings not set: {', '.join(missing_settings)}. "
+
+        for missing_setting in missing_settings:
+            if settings[missing_setting]["current_value"] is not None:
+                continue
+            event_info += generate_event_info_for_missing_setting(
+                missing_setting,
+                settings[missing_setting]["env_var"],
+                settings[missing_setting]["config_key"],
+            )
+
+        structlogger.error(
+            "azure_openai_llm_client.not_configured",
+            event_info=event_info,
+            missing_settings=missing_settings,
+        )
+        raise ProviderClientValidationError(event_info)

rasa/shared/providers/llm/_base_litellm_client.py

@@ -7,7 +7,12 @@ from typing import Any, Dict, List, Union, cast
 import structlog
 from litellm import acompletion, completion, validate_environment
 
-from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY, ROLE_USER
+from rasa.shared.constants import (
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+    API_BASE_CONFIG_KEY,
+    API_KEY,
+    ROLE_USER,
+)
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -21,8 +26,6 @@ from rasa.shared.utils.io import resolve_environment_variables, suppress_logs
 
 structlogger = structlog.get_logger()
 
-_VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
-
 # Suppress LiteLLM info and debug logs - Global level.
 logging.getLogger("LiteLLM").setLevel(logging.WARNING)
 

rasa/shared/providers/llm/azure_openai_llm_client.py

@@ -7,15 +7,12 @@ from typing import Any, Dict, Optional
 import structlog
 
 from rasa.shared.constants import (
-    API_BASE_CONFIG_KEY,
     API_KEY,
-    API_VERSION_CONFIG_KEY,
     AZURE_API_BASE_ENV_VAR,
     AZURE_API_KEY_ENV_VAR,
     AZURE_API_TYPE_ENV_VAR,
     AZURE_API_VERSION_ENV_VAR,
     AZURE_OPENAI_PROVIDER,
-    DEPLOYMENT_CONFIG_KEY,
     OPENAI_API_BASE_ENV_VAR,
     OPENAI_API_KEY_ENV_VAR,
     OPENAI_API_TYPE_ENV_VAR,
@@ -26,6 +23,7 @@ from rasa.shared.providers._configs.azure_openai_client_config import (
     AzureEntraIDOAuthConfig,
     AzureOpenAIClientConfig,
 )
+from rasa.shared.providers._utils import validate_azure_client_setup
 from rasa.shared.providers.constants import (
     DEFAULT_AZURE_API_KEY_NAME,
     LITE_LLM_API_BASE_FIELD,
@@ -348,68 +346,8 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
     def validate_client_setup(self) -> None:
         """Validates that all required configuration parameters are set."""
 
-        def generate_event_info_for_missing_setting(
-            setting: str,
-            setting_env_var: Optional[str] = None,
-            setting_config_key: Optional[str] = None,
-        ) -> str:
-            """Generate a part of the message with instructions on what to set
-            for the missing client setting.
-            """
-            info = "Set {setting} with {options}. "
-            options = ""
-            if setting_env_var is not None:
-                options += f"environment variable '{setting_env_var}'"
-            if setting_config_key is not None and setting_env_var is not None:
-                options += " or "
-            if setting_config_key is not None:
-                options += f"config key '{setting_config_key}'"
-
-            return info.format(setting=setting, options=options)
-
-        env_var_field = "env_var"
-        config_key_field = "config_key"
-        current_value_field = "current_value"
-        # All required settings for Azure OpenAI client
-        settings: Dict[str, Dict[str, Any]] = {
-            "API Base": {
-                current_value_field: self.api_base,
-                env_var_field: AZURE_API_BASE_ENV_VAR,
-                config_key_field: API_BASE_CONFIG_KEY,
-            },
-            "API Version": {
-                current_value_field: self.api_version,
-                env_var_field: AZURE_API_VERSION_ENV_VAR,
-                config_key_field: API_VERSION_CONFIG_KEY,
-            },
-            "Deployment Name": {
-                current_value_field: self.deployment,
-                env_var_field: None,
-                config_key_field: DEPLOYMENT_CONFIG_KEY,
-            },
-        }
-
-        missing_settings = [
-            setting_name
-            for setting_name, setting_info in settings.items()
-            if setting_info[current_value_field] is None
-        ]
-
-        if missing_settings:
-            event_info = f"Client settings not set: " f"{', '.join(missing_settings)}. "
-
-            for missing_setting in missing_settings:
-                if settings[missing_setting][current_value_field] is not None:
-                    continue
-                event_info += generate_event_info_for_missing_setting(
-                    missing_setting,
-                    settings[missing_setting][env_var_field],
-                    settings[missing_setting][config_key_field],
-                )
-
-            structlogger.error(
-                "azure_openai_llm_client.not_configured",
-                event_info=event_info,
-                missing_settings=missing_settings,
-            )
-            raise ProviderClientValidationError(event_info)
+        return validate_azure_client_setup(
+            api_base=self.api_base,
+            api_version=self.api_version,
+            deployment=self.deployment,
+        )

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -5,10 +5,16 @@ from copy import deepcopy
 from typing import Any, Dict, List
 
 import structlog
-from litellm import Router
+from litellm import Router, validate_environment
 
 from rasa.shared.constants import (
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+    API_BASE_CONFIG_KEY,
     API_KEY,
+    API_VERSION_CONFIG_KEY,
+    AZURE_API_BASE_ENV_VAR,
+    AZURE_API_VERSION_ENV_VAR,
+    AZURE_OPENAI_PROVIDER,
     LITELLM_PARAMS_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
@@ -23,6 +29,7 @@ from rasa.shared.providers._configs.azure_entra_id_config import AzureEntraIDOAu
 from rasa.shared.providers._configs.litellm_router_client_config import (
     LiteLLMRouterClientConfig,
 )
+from rasa.shared.providers._utils import validate_azure_client_setup
 from rasa.shared.utils.io import resolve_environment_variables
 
 structlogger = structlog.get_logger()
@@ -183,6 +190,7 @@ class _BaseLiteLLMRouterClient:
 
     def _create_router_client(self) -> Router:
         resolved_model_configurations = self._resolve_env_vars_in_model_configurations()
+        self._validate_model_configurations(resolved_model_configurations)
         return Router(model_list=resolved_model_configurations, **self.router_settings)
 
     def _has_oauth(self) -> bool:
@@ -214,3 +222,47 @@ class _BaseLiteLLMRouterClient:
                 )
             model_configuration_with_resolved_keys.append(resolved_model_configuration)
         return model_configuration_with_resolved_keys
+
+    def _validate_model_configurations(
+        self, resolved_model_configurations: List[Dict[str, Any]]
+    ) -> None:
+        """Validates the model configurations.
+        Args:
+            resolved_model_configurations: (List[Dict[str, Any]]) The list of model
+                configurations with resolved environment variables.
+        Raises:
+            ProviderClientValidationError: If the model configurations are invalid.
+        """
+        for model_configuration in resolved_model_configurations:
+            litellm_params = model_configuration.get(LITELLM_PARAMS_KEY, {})
+
+            model = litellm_params.get(MODEL_CONFIG_KEY)
+            provider, deployment = model.split("/", 1)
+            api_base = litellm_params.get(API_BASE_CONFIG_KEY)
+
+            if provider.lower() == AZURE_OPENAI_PROVIDER:
+                validate_azure_client_setup(
+                    api_base=api_base or os.getenv(AZURE_API_BASE_ENV_VAR),
+                    api_version=litellm_params.get(API_VERSION_CONFIG_KEY)
+                    or os.getenv(AZURE_API_VERSION_ENV_VAR),
+                    deployment=deployment,
+                )
+            else:
+                validation_info = validate_environment(
+                    model=model,
+                    api_key=litellm_params.get(API_KEY),
+                    api_base=api_base,
+                )
+                if missing_environment_variables := validation_info.get(
+                    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
+                ):
+                    event_info = (
+                        f"Environment variables: {missing_environment_variables} "
+                        f"not set. Required for API calls."
+                    )
+                    structlogger.error(
+                        "base_litellm_router_client.validate_environment_variables",
+                        event_info=event_info,
+                        missing_environment_variables=missing_environment_variables,
+                    )
+                    raise ProviderClientValidationError(event_info)

rasa/shared/utils/common.py

@@ -1,4 +1,5 @@
 import asyncio
+import copy
 import functools
 import importlib
 import inspect
@@ -288,6 +289,47 @@ def merge_lists_of_dicts(
     return list(merged_dicts.values())
 
 
+def partial_merge_list(
+    self_list: List[Any],
+    other_list: List[Any],
+    is_same_item_fn: Callable[[Any, Any], bool],
+) -> List[Any]:
+    """Merges two lists based on a custom intersection logic."""
+    matched_other_indices = set()
+    result = []
+
+    for s_item in self_list:
+        match = next(
+            (
+                (i, o_item)
+                for i, o_item in enumerate(other_list)
+                if i not in matched_other_indices and is_same_item_fn(s_item, o_item)
+            ),
+            None,
+        )
+        if match:
+            i, o_item = match
+            result.append(copy.deepcopy(o_item))
+            matched_other_indices.add(i)
+        else:
+            result.append(copy.deepcopy(s_item))
+
+    return result
+
+
+def partial_merge_dict(
+    self_d: Dict[Text, Any], other_d: Dict[Text, Any]
+) -> Dict[Text, Any]:
+    """Merges two dictionaries based on a custom intersection logic."""
+    merged = {}
+    for k, v in self_d.items():
+        if k in other_d:
+            merged[k] = copy.deepcopy(other_d[k])
+        else:
+            merged[k] = copy.deepcopy(v)
+    return merged
+
+
 def warn_and_exit_if_module_path_contains_rasa_plus(
     module_path: Text, lookup_path: Optional[str] = None
 ) -> None:

rasa/studio/download/domains.py

@@ -0,0 +1,49 @@
+import logging
+from pathlib import Path
+
+from rasa.shared.core.domain import (
+    Domain,
+)
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.studio.constants import STUDIO_DOMAIN_FILENAME
+
+logger = logging.getLogger(__name__)
+
+
+def merge_domain_with_overwrite(
+    data_from_studio: TrainingDataImporter,
+    data_local: TrainingDataImporter,
+    domain_path: Path,
+) -> None:
+    """
+    Merges the domain from Rasa Studio with the local domain.
+
+    Args:
+        data_from_studio: The training data importer for the Rasa Studio domain.
+        data_local: The training data importer for the local domain.
+        domain_path: The path to the domain file or directory.
+    """
+    if domain_path.is_file():
+        all_local_domain_files = [str(domain_path)]
+        domain_path = domain_path.parent
+    else:
+        all_local_domain_files = data_local.get_domain_files([str(domain_path)])
+
+    # leftover_domain represents the items in the studio
+    # domain that are not in the local domain
+    leftover_domain = data_from_studio.get_user_domain()
+    for file_path in all_local_domain_files:
+        # For each local domain file, we do a partial merge
+        local_domain = Domain.from_file(str(file_path))
+        updated_local_domain = local_domain.partial_merge(leftover_domain)
+
+        # If this partial merge made changes, persist them
+        if local_domain != updated_local_domain:
+            updated_local_domain.persist(file_path)
+
+        # Remove every item now present in updated_local_domain from leftover_domain
+        leftover_domain = leftover_domain.difference(updated_local_domain)
+
+    # If there are still items in leftover_domain, persist them
+    if not leftover_domain.is_empty():
+        leftover_domain.persist(domain_path / STUDIO_DOMAIN_FILENAME)