rasa-pro 3.11.3a1.dev2__py3-none-any.whl

rasa/shared/providers/_configs/huggingface_local_embedding_client_config.py

@@ -0,0 +1,234 @@
+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,
+    RASA_TYPE_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    HUGGINGFACE_MULTIPROCESS_CONFIG_KEY,
+    HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY,
+    HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY,
+    HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER,
+    PROVIDER_CONFIG_KEY,
+    HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    resolve_aliases,
+    raise_deprecation_warnings,
+    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,220 @@
+import copy
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+import structlog
+from rasa.shared.constants import (
+    ROUTER_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    LITELLM_PARAMS_KEY,
+    PROVIDER_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_LIST_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.model_group_config import (
+    ModelGroupConfig,
+    ModelConfig,
+)
+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

rasa/shared/providers/_configs/model_group_config.py

@@ -0,0 +1,167 @@
+from dataclasses import asdict, dataclass, field
+from typing import List, Optional
+
+import structlog
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_KEY,
+    API_TYPE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
+    EXTRA_PARAMETERS_KEY,
+)
+from rasa.shared.providers.mappings import get_client_config_class_from_provider
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ModelConfig:
+    """Parses the model config.
+
+    Raises:
+        ValueError: If the provider config key is missing in the config.
+    """
+
+    provider: str
+    model: Optional[str] = None
+    deployment: Optional[str] = None
+    api_base: Optional[str] = None
+    api_key: Optional[str] = None
+    api_version: Optional[str] = None
+    extra_parameters: dict = field(default_factory=dict)
+    # Retained for backward compatibility with older configurations,
+    # but intentionally not included in extra_parameters
+    api_type: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "ModelConfig":
+        """Initializes a dataclass from the passed config. The provider config param is
+        used to determine the client config class to use. The client config class takes
+        care of resolving config aliases and throwing deprecation warnings.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelConfig
+        """
+        from rasa.shared.utils.llm import get_provider_from_config
+
+        # Get the provider from config, this also inferring the provider from
+        # deprecated configurations
+        provider = get_provider_from_config(config)
+
+        # Retrieve the client configuration class for the specified provider.
+        client_config_clazz = get_client_config_class_from_provider(provider)
+
+        # Try to instantiate the config object in order to resolve deprecated
+        # aliases and throw deprecation warnings.
+        client_config_obj = client_config_clazz.from_dict(config)
+
+        # Convert back to dictionary and instantiate the ModelConfig object.
+        client_config = client_config_obj.to_dict()
+
+        # Check for provider after resolving all aliases
+        if PROVIDER_CONFIG_KEY not in client_config:
+            raise ValueError(
+                f"Missing required key '{PROVIDER_CONFIG_KEY}' in "
+                f"'{MODELS_CONFIG_KEY}' config."
+            )
+
+        return ModelConfig(
+            provider=client_config.pop(PROVIDER_CONFIG_KEY, None),
+            model=client_config.pop(MODEL_CONFIG_KEY, None),
+            deployment=client_config.pop(DEPLOYMENT_CONFIG_KEY, None),
+            api_type=client_config.pop(API_TYPE_CONFIG_KEY, None),
+            api_base=client_config.pop(API_BASE_CONFIG_KEY, None),
+            api_key=client_config.pop(API_KEY, None),
+            api_version=client_config.pop(API_VERSION_CONFIG_KEY, None),
+            extra_parameters=client_config,
+        )
+
+    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_KEY, None)
+        d.update(self.extra_parameters)
+
+        # Remove keys with None values
+        return {key: value for key, value in d.items() if value is not None}
+
+
+@dataclass
+class ModelGroupConfig:
+    """Parses the models config. The models config is a list of model configs.
+
+    Raises:
+        ValueError: If the model group ID is None or if the models list is empty.
+    """
+
+    model_group_id: str
+    models: List[ModelConfig]
+
+    def __post_init__(self) -> None:
+        if self.model_group_id is None:
+            message = "Model group ID cannot be set to None."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+        if not self.models:
+            message = "Models cannot be empty."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "ModelGroupConfig":
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelGroupConfig
+        """
+        if MODELS_CONFIG_KEY not in config:
+            raise ValueError(
+                f"Missing required key '{MODELS_CONFIG_KEY}' in "
+                f"'{MODEL_GROUPS_CONFIG_KEY}' config."
+            )
+
+        models_config = [
+            ModelConfig.from_dict(model_config)
+            for model_config in config[MODELS_CONFIG_KEY]
+        ]
+
+        return cls(
+            model_group_id=config.get(MODEL_GROUP_ID_CONFIG_KEY),
+            models=models_config,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = {
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODELS_CONFIG_KEY: [model.to_dict() for model in self.models],
+        }
+        return d