rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/shared/providers/_configs/client_config.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+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,132 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict
+
+import structlog
+
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    raise_deprecation_warnings,
+    resolve_aliases,
+    validate_forbidden_keys,
+    validate_required_keys,
+)
+
+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)

rasa/shared/providers/_configs/huggingface_local_embedding_client_config.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY,
+    HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER,
+    HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
+    HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_MULTIPROCESS_CONFIG_KEY,
+    HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    raise_deprecation_warnings,
+    resolve_aliases,
+    validate_required_keys,
+)
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+DEPRECATED_HUGGINGFACE_TYPE = "huggingface"
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Provider aliases
+    RASA_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+
+@dataclass
+class HuggingFaceLocalEmbeddingClientConfig:
+    """Parses configuration for HuggingFace local embeddings 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 `huggingface_local` or
+              `huggingface` (deprecated).
+    """
+
+    model: str
+
+    multi_process: Optional[bool]
+    cache_folder: Optional[str]
+    show_progress: Optional[bool]
+
+    # Provider is not actually used by sentence-transformers, but we define
+    # it here because it's used as a switch denominator for HuggingFace
+    # local embedding client.
+    provider: str = HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER
+
+    model_kwargs: dict = field(default_factory=dict)
+    encode_kwargs: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.provider != HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER:
+            message = (
+                f"API type must be set to '{HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}'."
+            )
+            structlogger.error(
+                "huggingface_local_embeddings_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.model is None:
+            message = "Model cannot be set to None."
+            structlogger.error(
+                "huggingface_local_embeddings_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> HuggingFaceLocalEmbeddingClientConfig:
+        """
+        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 usage of deprecated switching key and value:
+        # 1. type: huggingface
+        # 2. _type: huggingface
+        _raise_deprecation_warning_for_huggingface_deprecated_switch_value(config)
+        # Check for other 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)
+        this = HuggingFaceLocalEmbeddingClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            # Optional
+            multi_process=config.pop(HUGGINGFACE_MULTIPROCESS_CONFIG_KEY, False),
+            cache_folder=config.pop(
+                HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY,
+                str(HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER),
+            ),
+            show_progress=config.pop(HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY, False),
+            model_kwargs=config.pop(HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY, {}),
+            encode_kwargs=config.pop(HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY, {}),
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        return asdict(self)
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        config = _resolve_huggingface_deprecated_switch_value(config)
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+
+def is_huggingface_local_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure
+    a local HuggingFace embedding client.
+    """
+    # Hugging face special deprecated cases:
+    # 1. type: huggingface
+    # 2. _type: huggingface
+    # If the deprecated setting is detected resolve both alias key and key
+    # value. This would mean that the configurations above will be
+    # transformed to:
+    # provider: huggingface_local
+    config = HuggingFaceLocalEmbeddingClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: huggingface_local`
+    if config.get(PROVIDER_CONFIG_KEY) in [
+        HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
+    ]:
+        return True
+
+    return False
+
+
+def _raise_deprecation_warning_for_huggingface_deprecated_switch_value(
+    config: dict,
+) -> None:
+    deprecated_switch_keys = [RASA_TYPE_CONFIG_KEY, LANGCHAIN_TYPE_CONFIG_KEY]
+    deprecation_message = (
+        f"Configuration "
+        f"`{{deprecated_switch_key}}: {DEPRECATED_HUGGINGFACE_TYPE}` "
+        f"is deprecated and will be removed in 4.0.0. "
+        f"Please use "
+        f"`{PROVIDER_CONFIG_KEY}: {HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}` "
+        f"instead."
+    )
+    for deprecated_switch_key in deprecated_switch_keys:
+        if (
+            deprecated_switch_key in config
+            and config[deprecated_switch_key] == DEPRECATED_HUGGINGFACE_TYPE
+        ):
+            raise_deprecation_warning(
+                message=deprecation_message.format(
+                    deprecated_switch_key=deprecated_switch_key
+                )
+            )
+
+
+def _resolve_huggingface_deprecated_switch_value(config: dict) -> dict:
+    """
+    Resolve use of deprecated switching mechanism for HuggingFace local
+    embedding client.
+
+    The following settings (key + value) are deprecated:
+    1. `type: huggingface`
+    2. `_type: huggingface`
+    in favor of `provider: huggingface_local`.
+
+
+    Args:
+        config: given config
+
+    Returns:
+        New config with resolved switch mechanism
+
+    """
+    config = config.copy()
+
+    deprecated_switch_keys = [RASA_TYPE_CONFIG_KEY, LANGCHAIN_TYPE_CONFIG_KEY]
+    debug_message = (
+        f"Switching "
+        f"`{{deprecated_switch_key}}: {DEPRECATED_HUGGINGFACE_TYPE}` "
+        f"to `{PROVIDER_CONFIG_KEY}: {HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}`."
+    )
+
+    for deprecated_switch_key in deprecated_switch_keys:
+        if (
+            deprecated_switch_key in config
+            and config[deprecated_switch_key] == DEPRECATED_HUGGINGFACE_TYPE
+        ):
+            # Update configuration with new switch mechanism
+            config[PROVIDER_CONFIG_KEY] = HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER
+            # Pop the deprecated key used
+            config.pop(deprecated_switch_key, None)
+
+            structlogger.debug(
+                "HuggingFaceLocalEmbeddingClientConfig"
+                "._resolve_huggingface_deprecated_switch_value",
+                message=debug_message.format(
+                    deprecated_switch_key=deprecated_switch_key
+                ),
+                new_config=config,
+            )
+
+    return config

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.shared.constants import (
+    API_TYPE_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    LITELLM_PARAMS_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_LIST_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    ROUTER_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.model_group_config import (
+    ModelConfig,
+    ModelGroupConfig,
+)
+from rasa.shared.providers.mappings import get_prefix_from_provider
+from rasa.shared.utils.llm import DEPLOYMENT_CENTRIC_PROVIDERS
+
+structlogger = structlog.get_logger()
+
+_LITELLM_UNSUPPORTED_KEYS = [
+    PROVIDER_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+]
+
+
+@dataclass
+class LiteLLMRouterClientConfig:
+    """Parses configuration for a LiteLLM Router client. The configuration is expected
+    to be in the following format:
+
+    {
+        "id": "model_group_id",
+        "models": [
+            {
+                "provider": "provider_name",
+                "model": "model_name",
+                "api_base": "api_base",
+                "api_key": "api_key",
+                "api_version": "api_version",
+            },
+            {
+                "provider": "provider_name",
+                "model": "model_name",
+            },
+        "router": {}
+    }
+
+    This configuration is converted into the LiteLLM required format:
+
+    {
+        "id": "model_group_id",
+        "model_list": [
+            {
+                "model_name": "model_group_id",
+                "litellm_params": {
+                    "model": "provider_name/model_name",
+                    "api_base": "api_base",
+                    "api_key": "api_key",
+                    "api_version": "api_version",
+                },
+            },
+            {
+                "model_name": "model_group_id",
+                "litellm_params": {
+                    "model": "provider_name/model_name",
+                },
+            },
+        ],
+        "router": {},
+    }
+
+    Raises:
+        ValueError: If the configuration is missing required keys.
+    """
+
+    _model_group_config: ModelGroupConfig
+    router: Dict[str, Any]
+    _use_chat_completions_endpoint: bool = True
+    extra_parameters: dict = field(default_factory=dict)
+
+    @property
+    def model_group_id(self) -> str:
+        return self._model_group_config.model_group_id
+
+    @property
+    def models(self) -> List[ModelConfig]:
+        return self._model_group_config.models
+
+    @property
+    def litellm_model_list(self) -> List[Dict[str, Any]]:
+        return self._convert_models_to_litellm_model_list()
+
+    @property
+    def litellm_router_settings(self) -> Dict[str, Any]:
+        return self._convert_router_to_litellm_router_settings()
+
+    @property
+    def use_chat_completions_endpoint(self) -> bool:
+        return self._use_chat_completions_endpoint
+
+    def __post_init__(self) -> None:
+        if not self.router:
+            message = "Router cannot be empty."
+            structlogger.error(
+                "litellm_router_client_config.validation_error",
+                message=message,
+                model_group_id=self._model_group_config.model_group_id,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> LiteLLMRouterClientConfig:
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            LiteLLMRouterClientConfig
+        """
+        model_group_config = ModelGroupConfig.from_dict(config)
+
+        # Copy config to avoid mutating the original
+        config_copy = copy.deepcopy(config)
+        # Pop the keys used by ModelGroupConfig
+        config_copy.pop(MODEL_GROUP_ID_CONFIG_KEY, None)
+        config_copy.pop(MODELS_CONFIG_KEY, None)
+        # Get the router settings
+        router_settings = config_copy.pop(ROUTER_CONFIG_KEY, {})
+        # Get the use_chat_completions_endpoint setting
+        use_chat_completions_endpoint = router_settings.get(
+            USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, True
+        )
+        # The rest is considered as extra parameters
+        extra_parameters = config_copy
+
+        this = LiteLLMRouterClientConfig(
+            _model_group_config=model_group_config,
+            router=router_settings,
+            _use_chat_completions_endpoint=use_chat_completions_endpoint,
+            extra_parameters=extra_parameters,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = self._model_group_config.to_dict()
+        d[ROUTER_CONFIG_KEY] = self.router
+        if self.extra_parameters:
+            d.update(self.extra_parameters)
+        return d
+
+    def to_litellm_dict(self) -> dict:
+        return {
+            **self.extra_parameters,
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODEL_LIST_KEY: self._convert_models_to_litellm_model_list(),
+            ROUTER_CONFIG_KEY: self._convert_router_to_litellm_router_settings(),
+        }
+
+    def _convert_router_to_litellm_router_settings(self) -> Dict[str, Any]:
+        _router_settings_copy = copy.deepcopy(self.router)
+        _router_settings_copy.pop(USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, None)
+        return _router_settings_copy
+
+    def _convert_models_to_litellm_model_list(self) -> List[Dict[str, Any]]:
+        litellm_model_list = []
+
+        for model_config_object in self.models:
+            # Convert the model config to a dict representation
+            litellm_model_config = model_config_object.to_dict()
+
+            provider = litellm_model_config[PROVIDER_CONFIG_KEY]
+
+            # Get the litellm prefixing for the provider
+            prefix = get_prefix_from_provider(provider)
+
+            # Determine whether to use model or deployment key based on the provider.
+            litellm_model_name = (
+                litellm_model_config[DEPLOYMENT_CONFIG_KEY]
+                if provider in DEPLOYMENT_CENTRIC_PROVIDERS
+                else litellm_model_config[MODEL_CONFIG_KEY]
+            )
+
+            # Set 'model' to a provider prefixed model name e.g. openai/gpt-4
+            litellm_model_config[MODEL_CONFIG_KEY] = (
+                litellm_model_name
+                if f"{prefix}/" in litellm_model_name
+                else f"{prefix}/{litellm_model_name}"
+            )
+
+            # Remove parameters that are None and not supported by LiteLLM.
+            litellm_model_config = {
+                key: value
+                for key, value in litellm_model_config.items()
+                if key not in _LITELLM_UNSUPPORTED_KEYS and value is not None
+            }
+
+            litellm_model_list_item = {
+                MODEL_NAME_CONFIG_KEY: self.model_group_id,
+                LITELLM_PARAMS_KEY: litellm_model_config,
+            }
+
+            litellm_model_list.append(litellm_model_list_item)
+
+        return litellm_model_list