rasa-pro 3.9.18__py3-none-any.whl → 3.10.16__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/openai_client_config.py

@@ -0,0 +1,175 @@
+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,
+    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,
+    OPENAI_PROVIDER,
+    OPENAI_API_TYPE,
+)
+from rasa.shared.providers._configs.utils import (
+    resolve_aliases,
+    validate_required_keys,
+    raise_deprecation_warnings,
+    validate_forbidden_keys,
+)
+
+structlogger = structlog.get_logger()
+
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_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,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class OpenAIClientConfig:
+    """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 `openai`.
+    """
+
+    model: str
+    api_base: Optional[str]
+    api_version: Optional[str]
+
+    # API Type is not actually used by LiteLLM backend, but we define
+    # it here for backward compatibility.
+    api_type: str = OPENAI_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 = OPENAI_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        # In case of OpenAI hosting, it doesn't make sense
+        # for API type to be anything else that 'openai'
+        if self.api_type != OPENAI_API_TYPE:
+            message = f"API type must be set to '{OPENAI_API_TYPE}'."
+            structlogger.error(
+                "openai_client_config.validation_error",
+                message=message,
+                api_type=self.api_type,
+            )
+            raise ValueError(message)
+        if self.provider != OPENAI_PROVIDER:
+            message = f"Provider must be set to '{OPENAI_PROVIDER}'."
+            structlogger.error(
+                "openai_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(
+                "openai_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "OpenAIClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        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 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 = OpenAIClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            # Pop the 'provider' key. Currently, it's *optional* because of
+            # backward compatibility with older versions.
+            provider=config.pop(PROVIDER_CONFIG_KEY, OPENAI_PROVIDER),
+            # Optional parameters
+            api_base=config.pop(API_BASE_CONFIG_KEY, None),
+            api_version=config.pop(API_VERSION_CONFIG_KEY, None),
+            api_type=config.pop(API_TYPE_CONFIG_KEY, OPENAI_API_TYPE),
+            # 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_openai_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure
+    an OpenAI client.
+    """
+    # Process the config to handle all the aliases
+    config = OpenAIClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: openai`
+    if config.get(PROVIDER_CONFIG_KEY) == OPENAI_PROVIDER:
+        return True
+
+    return False

rasa/shared/providers/_configs/self_hosted_llm_client_config.py

@@ -0,0 +1,176 @@
+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,
+    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,
+    OPENAI_PROVIDER,
+    SELF_HOSTED_PROVIDER,
+    USE_CHAT_COMPLETIONS_ENDPOINT_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 = {
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_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,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [API_BASE_CONFIG_KEY, MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class SelfHostedLLMClientConfig:
+    """Parses configuration for Self Hosted 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
+    api_base: str
+    api_version: Optional[str] = None
+    api_type: Optional[str] = OPENAI_PROVIDER
+    use_chat_completions_endpoint: Optional[bool] = True
+    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(
+                "self_hosted_llm_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(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.api_base is None:
+            message = "API base cannot be set to None."
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.api_type != OPENAI_PROVIDER:
+            message = (
+                f"Currently supports only {OPENAI_PROVIDER} endpoints. "
+                f"API type must be set to '{OPENAI_PROVIDER}'."
+            )
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                api_type=self.api_type,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "SelfHostedLLMClientConfig":
+        """
+        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)
+        # 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 = SelfHostedLLMClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            api_base=config.pop(API_BASE_CONFIG_KEY),
+            # Optional parameters
+            api_type=config.pop(API_TYPE_CONFIG_KEY, OPENAI_PROVIDER),
+            api_version=config.pop(API_VERSION_CONFIG_KEY, None),
+            use_chat_completions_endpoint=config.pop(
+                USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, True
+            ),
+            # 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)
+
+
+def is_self_hosted_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure an self-hosted client."""
+    # Process the config to handle all the aliases
+    config = SelfHostedLLMClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: self-hosted`
+    if config.get(PROVIDER_CONFIG_KEY) == SELF_HOSTED_PROVIDER:
+        return True
+
+    return False

rasa/shared/providers/_configs/utils.py

@@ -0,0 +1,101 @@
+import structlog
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+
+def resolve_aliases(config: dict, deprecated_alias_mapping: dict) -> dict:
+    """
+    Resolve aliases in the configuration to standard keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping aliases to
+            their standard keys.
+
+    Returns:
+        New dictionary containing the processed configuration.
+    """
+    config = config.copy()
+
+    for alias, standard_key in deprecated_alias_mapping.items():
+        # We check for the alias instead of the standard key because our goal is to
+        # update the standard key when the alias is found. Since the standard key is
+        # always included in the default component configurations, we overwrite it
+        # with the alias value if the alias exists.
+        if alias in config:
+            config[standard_key] = config.pop(alias)
+
+    return config
+
+
+def raise_deprecation_warnings(config: dict, deprecated_alias_mapping: dict) -> None:
+    """
+    Raises warnings for deprecated keys in the configuration.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping deprecated keys to
+            their standard keys.
+
+    Raises:
+        DeprecationWarning: If any deprecated key is found in the config.
+    """
+    for alias, standard_key in deprecated_alias_mapping.items():
+        if alias in config:
+            raise_deprecation_warning(
+                message=(
+                    f"'{alias}' is deprecated and will be removed in "
+                    f"4.0.0. Use '{standard_key}' instead."
+                )
+            )
+
+
+def validate_required_keys(config: dict, required_keys: list) -> None:
+    """
+    Validates that the passed config contains all the required keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        required_keys: List of keys that must be present in the config.
+
+    Raises:
+        ValueError: If any required key is missing.
+    """
+    missing_keys = [key for key in required_keys if key not in config]
+    if missing_keys:
+        message = f"Missing required keys '{missing_keys}' for configuration."
+        structlogger.error(
+            "validate_required_keys",
+            message=message,
+            missing_keys=missing_keys,
+            config=config,
+        )
+        raise ValueError(message)
+
+
+def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
+    """
+    Validates that the passed config doesn't contain any forbidden keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        forbidden_keys: List of keys that are forbidden in the config.
+
+    Raises:
+        ValueError: If any forbidden key is present.
+    """
+    forbidden_keys_in_config = set(config.keys()).intersection(set(forbidden_keys))
+
+    if forbidden_keys_in_config:
+        message = (
+            f"Forbidden keys '{forbidden_keys_in_config}' present "
+            f"in the configuration."
+        )
+        structlogger.error(
+            "validate_forbidden_keys",
+            message=message,
+            forbidden_keys=forbidden_keys_in_config,
+            config=config,
+        )
+        raise ValueError(message)