rasa-pro 3.9.18__py3-none-any.whl → 3.10.16__py3-none-any.whl

rasa/shared/importers/importer.py

@@ -1,28 +1,30 @@
+from __future__ import annotations
+
+import logging
 from abc import ABC, abstractmethod
 from functools import reduce
-from typing import Text, Optional, List, Dict, Set, Any, Tuple, Type, Union, cast
-import logging
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Type, Union, cast
 
 import importlib_resources
 
 import rasa.shared.constants
-from rasa.shared.core.flows import FlowsList
-import rasa.shared.utils.common
 import rasa.shared.core.constants
+import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.core.domain import (
-    Domain,
+    IS_RETRIEVAL_INTENT_KEY,
+    KEY_ACTIONS,
     KEY_E2E_ACTIONS,
     KEY_INTENTS,
     KEY_RESPONSES,
-    KEY_ACTIONS,
+    Domain,
 )
 from rasa.shared.core.events import ActionExecuted, UserUttered
+from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.nlu.constants import ENTITIES, ACTION_NAME
-from rasa.shared.core.domain import IS_RETRIEVAL_INTENT_KEY
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger(__name__)
@@ -114,7 +116,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads a `TrainingDataImporter` instance from a configuration file."""
         config = read_config_file(config_path)
         return TrainingDataImporter.load_from_dict(
@@ -127,7 +129,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads core `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read Core training data.
@@ -143,7 +145,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads nlu `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read NLU training data.
@@ -165,8 +167,8 @@ class TrainingDataImporter(ABC):
         config_path: Optional[Text] = None,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+        args: Optional[Dict[Text, Any]] = None,
+    ) -> TrainingDataImporter:
         """Loads a `TrainingDataImporter` instance from a dictionary."""
         from rasa.shared.importers.rasa import RasaFileImporter
 
@@ -194,8 +196,8 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
-    ) -> Optional["TrainingDataImporter"]:
+        args: Optional[Dict[Text, Any]] = None,
+    ) -> Optional[TrainingDataImporter]:
         from rasa.shared.importers.multi_project import MultiProjectImporter
         from rasa.shared.importers.rasa import RasaFileImporter
 
@@ -216,7 +218,6 @@ class TrainingDataImporter(ABC):
         constructor_arguments = rasa.shared.utils.common.minimal_kwargs(
             {**importer_config, **(args or {})}, importer_class
         )
-
         return importer_class(
             config_path,
             domain_path,
@@ -232,6 +233,26 @@ class TrainingDataImporter(ABC):
         """Returns text representation of object."""
         return self.__class__.__name__
 
+    def get_user_flows(self) -> FlowsList:
+        """Retrieves the user-defined flows that should be used for training.
+
+        Implemented by FlowSyncImporter and E2EImporter only.
+
+        Returns:
+            `FlowsList` containing all loaded flows.
+        """
+        raise NotImplementedError
+
+    def get_user_domain(self) -> Domain:
+        """Retrieves the user-defined domain that should be used for training.
+
+        Implemented by FlowSyncImporter and E2EImporter only.
+
+        Returns:
+            `Domain`.
+        """
+        raise NotImplementedError
+
 
 class NluDataImporter(TrainingDataImporter):
     """Importer that skips any Core-related file reading."""
@@ -448,6 +469,10 @@ class FlowSyncImporter(PassThroughImporter):
 
         return self.merge_with_default_flows(flows)
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_flows(self) -> FlowsList:
+        return self._importer.get_flows()
+
     @rasa.shared.utils.common.cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of flows."""
@@ -476,6 +501,11 @@ class FlowSyncImporter(PassThroughImporter):
         )
         return domain
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_domain(self) -> Domain:
+        """Retrieves only user defined domain."""
+        return self._importer.get_domain()
+
 
 class ResponsesSyncImporter(PassThroughImporter):
     """Importer that syncs `responses` between Domain and NLU training data.
@@ -602,6 +632,15 @@ class E2EImporter(PassThroughImporter):
     - adds potential end-to-end bot messages from stories as actions to the domain
     """
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_flows(self) -> FlowsList:
+        if not isinstance(self._importer, FlowSyncImporter):
+            raise NotImplementedError(
+                "Accessing user flows is only supported with FlowSyncImporter."
+            )
+
+        return self._importer.get_user_flows()
+
     @rasa.shared.utils.common.cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
@@ -610,6 +649,15 @@ class E2EImporter(PassThroughImporter):
 
         return original.merge(e2e_domain)
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_domain(self) -> Domain:
+        """Retrieves only user defined domain."""
+        if not isinstance(self._importer, FlowSyncImporter):
+            raise NotImplementedError(
+                "Accessing user domain is only supported with FlowSyncImporter."
+            )
+        return self._importer.get_user_domain()
+
     def _get_domain_with_e2e_actions(self) -> Domain:
         stories = self.get_stories()
 

rasa/shared/nlu/constants.py

@@ -2,6 +2,8 @@ TEXT = "text"
 TEXT_TOKENS = "text_tokens"
 INTENT = "intent"
 COMMANDS = "commands"
+LLM_COMMANDS = "llm_commands"  # needed for fine-tuning
+LLM_PROMPT = "llm_prompt"  # needed for fine-tuning
 FLOWS_FROM_SEMANTIC_SEARCH = "flows_from_semantic_search"
 FLOWS_IN_PROMPT = "flows_in_prompt"
 NOT_INTENT = "not_intent"

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -0,0 +1,183 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    OPENAI_API_BASE_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+    OPENAI_API_TYPE_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    OPENAI_API_VERSION_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    DEPLOYMENT_NAME_CONFIG_KEY,
+    ENGINE_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    AZURE_OPENAI_PROVIDER,
+    AZURE_API_TYPE,
+)
+from rasa.shared.providers._configs.utils import (
+    resolve_aliases,
+    raise_deprecation_warnings,
+    validate_required_keys,
+    validate_forbidden_keys,
+)
+
+structlogger = structlog.get_logger()
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Deployment name aliases
+    DEPLOYMENT_NAME_CONFIG_KEY: DEPLOYMENT_CONFIG_KEY,
+    ENGINE_CONFIG_KEY: DEPLOYMENT_CONFIG_KEY,
+    # Provider aliases
+    RASA_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    # API type aliases
+    OPENAI_API_TYPE_CONFIG_KEY: API_TYPE_CONFIG_KEY,
+    # API base aliases
+    OPENAI_API_BASE_CONFIG_KEY: API_BASE_CONFIG_KEY,
+    # API version aliases
+    OPENAI_API_VERSION_CONFIG_KEY: API_VERSION_CONFIG_KEY,
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [DEPLOYMENT_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class AzureOpenAIClientConfig:
+    """Parses configuration for Azure OpenAI client, resolves aliases and
+    raises deprecation warnings.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+            - If `api_type` has a value different from `azure`.
+    """
+
+    deployment: str
+
+    model: Optional[str]
+    api_base: Optional[str]
+    api_version: Optional[str]
+    # API Type is not used by LiteLLM backend, but we define
+    # it here for backward compatibility.
+    api_type: Optional[str] = AZURE_API_TYPE
+
+    # Provider is not used by LiteLLM backend, but we define it here since it's
+    # used as switch between different clients.
+    provider: str = AZURE_OPENAI_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.provider != AZURE_OPENAI_PROVIDER:
+            message = f"Provider must be set to '{AZURE_OPENAI_PROVIDER}'."
+            structlogger.error(
+                "azure_openai_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.deployment is None:
+            message = "Deployment cannot be set to None."
+            structlogger.error(
+                "azure_openai_client_config.validation_error",
+                message=message,
+                deployment=self.deployment,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "AzureOpenAIClientConfig":
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Raised in cases of invalid configuration:
+                - If any of the required configuration keys are missing.
+                - If `api_type` has a value different from `azure`.
+
+        Returns:
+            AzureOpenAIClientConfig
+        """
+        # Check for deprecated keys
+        raise_deprecation_warnings(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+        # Resolve any potential aliases
+        config = cls.resolve_config_aliases(config)
+        # Validate that required keys are set
+        validate_required_keys(config, REQUIRED_KEYS)
+        # Validate that the forbidden keys are not present
+        validate_forbidden_keys(config, FORBIDDEN_KEYS)
+        # Init client config
+        this = AzureOpenAIClientConfig(
+            # Required parameters
+            deployment=config.pop(DEPLOYMENT_CONFIG_KEY),
+            # Pop the 'provider' key. Currently, it's *optional* because of
+            # backward compatibility with older versions.
+            provider=config.pop(PROVIDER_CONFIG_KEY, AZURE_OPENAI_PROVIDER),
+            # Optional
+            api_type=config.pop(API_TYPE_CONFIG_KEY, AZURE_API_TYPE),
+            model=config.pop(MODEL_CONFIG_KEY, None),
+            # Optional, can also be set through environment variables
+            # in clients.
+            api_base=config.pop(API_BASE_CONFIG_KEY, None),
+            api_version=config.pop(API_VERSION_CONFIG_KEY, None),
+            # The rest of parameters (e.g. model parameters) are considered
+            # as extra parameters (this also includes timeout).
+            extra_parameters=config,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+
+def is_azure_openai_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure
+    an Azure OpenAI client.
+    """
+    # Resolve any aliases that are specific to Azure OpenAI configuration
+    config = AzureOpenAIClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: azure`.
+    if config.get(PROVIDER_CONFIG_KEY) == AZURE_OPENAI_PROVIDER:
+        return True
+
+    # Case: Configuration contains `deployment` key
+    # (specific to Azure OpenAI configuration)
+    if (
+        config.get(DEPLOYMENT_CONFIG_KEY) is not None
+        and config.get(PROVIDER_CONFIG_KEY) is None
+    ):
+        return True
+
+    return False

rasa/shared/providers/_configs/client_config.py

@@ -0,0 +1,57 @@
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ClientConfig(Protocol):
+    """
+    Protocol for the client config that specifies the interface for interacting
+    with the API.
+    """
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "ClientConfig":
+        """
+        Initializes the client config with the given configuration.
+
+        This class method should be implemented to parse the given
+        configuration and create an instance of an client config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ClientConfig
+        """
+        ...
+
+    def to_dict(self) -> dict:
+        """
+        Returns the configuration for that the client config is initialized with.
+
+        This method should be implemented to return a dictionary containing
+        the configuration settings for the client config.
+
+        Returns:
+            dictionary containing the configuration settings for the client config.
+        """
+        ...
+
+    @staticmethod
+    def resolve_config_aliases(config: dict) -> dict:
+        """
+        Resolve any potential aliases in the configuration.
+
+        This method should be implemented to resolve any potential aliases in the
+        configuration.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Returns:
+            dictionary containing the resolved configuration settings for the
+            client config.
+        """
+        ...

rasa/shared/providers/_configs/default_litellm_client_config.py

@@ -0,0 +1,130 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    validate_required_keys,
+    validate_forbidden_keys,
+    resolve_aliases,
+    raise_deprecation_warnings,
+)
+import rasa.shared.utils.cli
+
+structlogger = structlog.get_logger()
+
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class DefaultLiteLLMClientConfig:
+    """Parses configuration for default LiteLLM client, resolves aliases and
+    raises deprecation warnings.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+    """
+
+    model: str
+    provider: str
+    extra_parameters: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.model is None:
+            message = "Model cannot be set to None."
+            structlogger.error(
+                "default_litellm_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+        if self.provider is None:
+            message = "Provider cannot be set to None."
+            structlogger.error(
+                "default_litellm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "DefaultLiteLLMClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            DefaultLiteLLMClientConfig
+        """
+        # Check for deprecated keys
+        raise_deprecation_warnings(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+        # Raise error for using `model_name` instead instead of `model`
+        cls.check_and_error_for_model_name_in_config(config)
+        # Resolve any potential aliases.
+        config = cls.resolve_config_aliases(config)
+        # Validate that the required keys are present
+        validate_required_keys(config, REQUIRED_KEYS)
+        # Validate that the forbidden keys are not present
+        validate_forbidden_keys(config, FORBIDDEN_KEYS)
+        this = DefaultLiteLLMClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            # The rest of parameters (e.g. model parameters) are considered
+            # as extra parameters
+            extra_parameters=config,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+    @staticmethod
+    def check_and_error_for_model_name_in_config(config: Dict[str, Any]) -> None:
+        """Check for usage of deprecated model_name and raise an error if found."""
+        if config.get(MODEL_NAME_CONFIG_KEY) and not config.get(MODEL_CONFIG_KEY):
+            event_info = (
+                f"Unsupported parameter - {MODEL_NAME_CONFIG_KEY} is set. Please use "
+                f"{MODEL_CONFIG_KEY} instead."
+            )
+            structlogger.error(
+                "default_litellm_client_config.unsupported_parameter_in_config",
+                event_info=event_info,
+                config=config,
+            )
+            rasa.shared.utils.cli.print_error_and_exit(event_info)