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

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -1,24 +1,10 @@
-from __future__ import annotations
-
-import logging
-from abc import abstractmethod
 from dataclasses import asdict, dataclass, field
-from enum import Enum
-from functools import lru_cache
-from typing import Any, Callable, Coroutine, Dict, List, Optional, Protocol, Set
+from typing import Any, Dict, Optional
 
 import structlog
-from azure.core.credentials import TokenProvider
-from azure.identity import (
-    CertificateCredential,
-    ClientSecretCredential,
-    DefaultAzureCredential,
-    get_bearer_token_provider,
-)
 
 from rasa.shared.constants import (
     API_BASE_CONFIG_KEY,
-    API_KEY,
     API_TYPE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     AZURE_API_TYPE,
@@ -75,459 +61,6 @@ FORBIDDEN_KEYS = [
 ]
 
 
-AZURE_CLIENT_ID_FIELD = "client_id"
-AZURE_CLIENT_SECRET_FIELD = "client_secret"
-AZURE_TENANT_ID_FIELD = "tenant_id"
-AZURE_CERTIFICATE_PATH_FIELD = "certificate_path"
-AZURE_CERTIFICATE_PASSWORD_FIELD = "certificate_password"
-AZURE_SEND_CERTIFICATE_CHAIN_FIELD = "send_certificate_chain"
-AZURE_SCOPES_FIELD = "scopes"
-AZURE_AUTHORITY_FIELD = "authority_host"
-AZURE_DISABLE_INSTANCE_DISCOVERY_FIELD = "disable_instance_discovery"
-OAUTH_TYPE_FIELD = "type"
-AZURE_OAUTH_KEY = "oauth"
-
-
-azure_logger = logging.getLogger("azure")
-azure_logger.setLevel(logging.DEBUG)
-
-
-class AzureOAuthType(str, Enum):
-    AZURE_DEFAULT = "default"
-    AZURE_CLIENT_SECRET = "client_secret"
-    AZURE_CLIENT_CERTIFICATE = "client_certificate"
-    # Invalid type is used to indicate that the type
-    # configuration is invalid or not set.
-    INVALID = "invalid"
-
-    @staticmethod
-    def from_string(value: Optional[str]) -> AzureOAuthType:
-        if value is None or value not in AzureOAuthType.valid_string_values():
-            return AzureOAuthType.INVALID
-
-        return AzureOAuthType(value)
-
-    @staticmethod
-    def valid_string_values() -> Set[str]:
-        return {e.value for e in AzureOAuthType.valid_values()}
-
-    @staticmethod
-    def valid_values() -> Set[AzureOAuthType]:
-        return {
-            AzureOAuthType.AZURE_DEFAULT,
-            AzureOAuthType.AZURE_CLIENT_SECRET,
-            AzureOAuthType.AZURE_CLIENT_CERTIFICATE,
-        }
-
-
-class AzureAuthType(str, Enum):
-    API_KEY = "api_key"
-    OAUTH = "oauth"
-
-    @staticmethod
-    def from_string(value: str) -> AzureAuthType:
-        try:
-            return AzureAuthType(value)
-        except ValueError:
-            raise ValueError(f"Invalid AzureAuthType value: {value}")
-
-    def __str__(self) -> str:
-        return self.value
-
-
-DEFAULT_AUTH_TYPE = AzureAuthType.API_KEY
-
-
-BearerTokenProvider = Callable[[], Coroutine[Any, Any, str]]
-
-
-class AzureEntraIDCredential(Protocol):
-    @abstractmethod
-    def create_azure_credential(self) -> TokenProvider: ...
-    @abstractmethod
-    def to_dict(self) -> dict: ...
-
-
-@dataclass
-class AzureClientCredentialsConfig:
-    """Azure OAuth client credentials configuration.
-
-    Attributes:
-        client_id: The client ID.
-        client_secret: The client secret.
-        tenant_id: The tenant ID.
-        authority_host: The authority host.
-        disable_instance_discovery: Whether to disable instance discovery. This is used
-            to disable fetching metadata from the Azure Instance Metadata Service.
-    """
-
-    client_id: str
-    client_secret: str
-    tenant_id: str
-    authority_host: Optional[str] = None
-    disable_instance_discovery: bool = False
-
-    @staticmethod
-    def required_fields() -> Set[str]:
-        """Returns the required fields for the configuration."""
-        return {AZURE_CLIENT_ID_FIELD, AZURE_TENANT_ID_FIELD, AZURE_CLIENT_SECRET_FIELD}
-
-    @staticmethod
-    def config_has_required_fields(config: Dict[str, Any]) -> bool:
-        """Check if the configuration has all the required fields."""
-        return AzureClientCredentialsConfig.required_fields().issubset(
-            set(config.keys())
-        )
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> AzureClientCredentialsConfig:
-        """Initializes a dataclass from the passed config.
-
-        Args:
-            config: (dict) The config from which to initialize.
-
-        Returns:
-            AzureClientCredentialsConfig
-        """
-        if not cls.config_has_required_fields(config):
-            message = (
-                f"A configuration for Azure client credentials "
-                f"must contain the following keys: {cls.required_fields()}"
-            )
-            structlogger.error(
-                "azure_client_credentials_config.missing_required_keys",
-                message=message,
-                config=config,
-            )
-            raise ValueError(message)
-
-        return cls(
-            client_id=config.pop(AZURE_CLIENT_ID_FIELD),
-            client_secret=config.pop(AZURE_CLIENT_SECRET_FIELD),
-            tenant_id=config.pop(AZURE_TENANT_ID_FIELD),
-            authority_host=config.pop(AZURE_AUTHORITY_FIELD, None),
-            disable_instance_discovery=config.pop(
-                AZURE_DISABLE_INSTANCE_DISCOVERY_FIELD, False
-            ),
-        )
-
-    def to_dict(self) -> dict:
-        """Converts the config instance into a dictionary."""
-        result = asdict(self)
-        result[OAUTH_TYPE_FIELD] = AzureOAuthType.AZURE_CLIENT_SECRET.value
-        return result
-
-    def create_azure_credential(self) -> TokenProvider:
-        return create_client_credentials(
-            client_id=self.client_id,
-            client_secret=self.client_secret,
-            tenant_id=self.tenant_id,
-            authority_host=self.authority_host,
-            disable_instance_discovery=self.disable_instance_discovery,
-        )
-
-
-@lru_cache
-def create_client_credentials(
-    client_id: str,
-    client_secret: str,
-    tenant_id: str,
-    authority_host: Optional[str] = None,
-    disable_instance_discovery: bool = False,
-) -> ClientSecretCredential:
-    """Create a ClientSecretCredential.
-
-    We cache the result of this function to avoid creating multiple instances
-    of the same credential. This makes it possible to utilise the token caching
-    functionality of the azure-identity library.
-
-    Args:
-        client_id: The client ID.
-        client_secret: The client secret.
-        tenant_id: The tenant ID.
-        authority_host: The authority host.
-        disable_instance_discovery: Whether to disable instance discovery. This is used
-            to disable fetching metadata from the Azure Instance Metadata Service.
-
-    Returns:
-        ClientSecretCredential
-    """
-    return ClientSecretCredential(
-        client_id=client_id,
-        client_secret=client_secret,
-        tenant_id=tenant_id,
-        authority=authority_host,
-        disable_instance_discovery=disable_instance_discovery,
-    )
-
-
-@dataclass
-class AzureClientCertificateConfig:
-    """Azure OAuth client certificate configuration.
-
-    Attributes:
-        client_id: The client ID.
-        tenant_id: The tenant ID.
-        certificate_path: The path to the certificate file.
-        certificate_password: The certificate password.
-        send_certificate_chain: Whether to send the certificate chain.
-        authority_host: The authority host.
-        disable_instance_discovery: Whether to disable instance discovery. This is used
-            to disable fetching metadata from the Azure Instance Metadata Service.
-    """
-
-    client_id: str
-    tenant_id: str
-    certificate_path: str
-    certificate_password: Optional[str] = None
-    send_certificate_chain: bool = False
-    authority_host: Optional[str] = None
-    disable_instance_discovery: bool = False
-
-    @staticmethod
-    def required_fields() -> Set[str]:
-        """Returns the required fields for the configuration."""
-        return {
-            AZURE_CLIENT_ID_FIELD,
-            AZURE_TENANT_ID_FIELD,
-            AZURE_CERTIFICATE_PATH_FIELD,
-            AZURE_CERTIFICATE_PASSWORD_FIELD,
-        }
-
-    @staticmethod
-    def config_has_required_fields(config: Dict[str, Any]) -> bool:
-        """Check if the configuration has all the required fields."""
-        return AzureClientCertificateConfig.required_fields().issubset(
-            set(config.keys())
-        )
-
-    @classmethod
-    def from_config(
-        cls, config: Dict[str, Any]
-    ) -> Optional[AzureClientCertificateConfig]:
-        """Initializes a dataclass from the passed config.
-
-        Args:
-            config: (dict) The config from which to initialize.
-
-        Returns:
-            AzureClientCertificateConfig
-        """
-        if not cls.config_has_required_fields(config):
-            message = (
-                f"A configuration for Azure client certificate "
-                f"must contain "
-                f"the following keys: {cls.required_fields()}"
-            )
-            structlogger.error(
-                "azure_client_certificate_config.validation_error",
-                message=message,
-                config=config,
-            )
-            raise ValueError(message)
-
-        return cls(
-            client_id=config[AZURE_CLIENT_ID_FIELD],
-            tenant_id=config[AZURE_TENANT_ID_FIELD],
-            certificate_path=config[AZURE_CERTIFICATE_PATH_FIELD],
-            certificate_password=config.get(AZURE_CERTIFICATE_PASSWORD_FIELD, None),
-            authority_host=config.get(AZURE_AUTHORITY_FIELD, None),
-            send_certificate_chain=config.get(
-                AZURE_SEND_CERTIFICATE_CHAIN_FIELD, False
-            ),
-            disable_instance_discovery=config.get(
-                AZURE_DISABLE_INSTANCE_DISCOVERY_FIELD, False
-            ),
-        )
-
-    def to_dict(self) -> dict:
-        """Converts the config instance into a dictionary."""
-        result = asdict(self)
-        result[OAUTH_TYPE_FIELD] = AzureOAuthType.AZURE_CLIENT_CERTIFICATE.value
-        return result
-
-    def create_azure_credential(self) -> TokenProvider:
-        return create_certificate_credentials(
-            client_id=self.client_id,
-            tenant_id=self.tenant_id,
-            certificate_path=self.certificate_path,
-            password=self.certificate_password,
-            send_certificate_chain=self.send_certificate_chain,
-            authority_host=self.authority_host,
-            disable_instance_discovery=self.disable_instance_discovery,
-        )
-
-
-@lru_cache
-def create_certificate_credentials(
-    tenant_id: str,
-    client_id: str,
-    certificate_path: Optional[str] = None,
-    password: Optional[str] = None,
-    send_certificate_chain: bool = False,
-    authority_host: Optional[str] = None,
-    disable_instance_discovery: bool = False,
-) -> CertificateCredential:
-    """Create a CertificateCredential.
-
-    We cache the result of this function to avoid creating multiple instances
-    of the same credential. This makes it possible to utilise the token caching
-    functionality of the azure-identity library.
-
-    Args:
-        tenant_id: The tenant ID.
-        client_id: The client ID.
-        certificate_path: The path to the certificate file.
-        password: The certificate password.
-        send_certificate_chain: Whether to send the certificate chain.
-        authority_host: The authority host.
-        disable_instance_discovery: Whether to disable instance discovery. This is used
-
-    Returns:
-        CertificateCredential
-    """
-
-    return CertificateCredential(
-        client_id=client_id,
-        tenant_id=tenant_id,
-        certificate_path=certificate_path,
-        password=password.encode("utf-8") if password else None,
-        send_certificate_chain=send_certificate_chain,
-        authority=authority_host,
-        disable_instance_discovery=disable_instance_discovery,
-    )
-
-
-@dataclass
-class AzureOAuthDefaultCredentialsConfig:
-    """Azure OAuth default credentials configuration.
-
-    Attributes:
-        authority_host: The authority host.
-    """
-
-    authority_host: Optional[str] = None
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> AzureOAuthDefaultCredentialsConfig:
-        """Initializes a dataclass from the passed config.
-
-        Args:
-            config: (dict) The config from which to initialize.
-
-        Returns:
-            AzureOAuthDefaultCredentialsConfig
-        """
-        return cls(authority_host=config.pop(AZURE_AUTHORITY_FIELD, None))
-
-    def to_dict(self) -> dict:
-        """Converts the config instance into a dictionary."""
-        result = asdict(self)
-        result[OAUTH_TYPE_FIELD] = AzureOAuthType.AZURE_DEFAULT.value
-        return result
-
-    def create_azure_credential(self) -> TokenProvider:
-        return create_default_credentials(authority_host=self.authority_host)
-
-
-@lru_cache
-def create_default_credentials(
-    authority_host: Optional[str] = None,
-) -> DefaultAzureCredential:
-    """Create a DefaultAzureCredential.
-
-    We cache the result of this function to avoid creating multiple instances
-    of the same credential. This makes it possible to utilise the token caching
-    functionality of the azure-identity library.
-
-    Args:
-        authority_host: The authority host.
-
-    Returns:
-        DefaultAzureCredential
-    """
-    return DefaultAzureCredential(authority=authority_host)
-
-
-@dataclass
-class AzureOAuthConfig:
-    scopes: List[str]
-    azure_credentials: Optional[AzureEntraIDCredential] = None
-
-    @classmethod
-    def from_config(cls, oauth_config: Dict[str, Any]) -> AzureOAuthConfig:
-        """Initializes a dataclass from the passed config.
-
-        Args:
-            oauth_config: (dict) The config from which to initialize.
-
-        Returns:
-            AzureOAuthConfig
-        """
-        oauth_type = AzureOAuthType.from_string(
-            oauth_config.pop(OAUTH_TYPE_FIELD, None)
-        )
-
-        if oauth_type == AzureOAuthType.INVALID:
-            message = (
-                "Azure Entra ID oauth configuration must contain "
-                f"'{OAUTH_TYPE_FIELD}' field and it must be set to one of the "
-                f"following values: {AzureOAuthType.valid_string_values()}, "
-            )
-            structlogger.error(
-                "azure_oauth_config.missing_oauth_type",
-                message=message,
-            )
-            raise ValueError(message)
-
-        azure_credentials = None
-        if oauth_type == AzureOAuthType.AZURE_CLIENT_SECRET:
-            azure_credentials = AzureClientCredentialsConfig.from_config(oauth_config)
-        elif oauth_type == AzureOAuthType.AZURE_CLIENT_CERTIFICATE:
-            azure_credentials = AzureClientCertificateConfig.from_config(oauth_config)
-        elif oauth_type == AzureOAuthType.AZURE_DEFAULT:
-            azure_credentials = AzureOAuthDefaultCredentialsConfig.from_config(
-                oauth_config
-            )
-
-        scopes = oauth_config.pop(AZURE_SCOPES_FIELD, "")
-
-        if not scopes:
-            message = "Azure Entra ID scopes cannot be empty."
-            structlogger.error(
-                "azure_oauth_config.scopes_empty",
-                message=message,
-            )
-            raise ValueError(message)
-
-        if isinstance(scopes, str):
-            scopes = [scopes]
-
-        return cls(azure_credentials=azure_credentials, scopes=scopes)
-
-    def create_azure_credential(
-        self,
-    ) -> TokenProvider:
-        return self.azure_credentials.create_azure_credential()
-
-    def to_dict(self) -> dict:
-        """Converts the config instance into a dictionary."""
-        credentials_dict = (
-            self.azure_credentials.to_dict() if self.azure_credentials else {}
-        )
-        result = asdict(self)
-        result.update(credentials_dict)
-        result.pop("azure_credentials", None)
-        return result
-
-    def get_bearer_token_provider(self) -> BearerTokenProvider:
-        return get_bearer_token_provider(self.create_azure_credential(), *self.scopes)
-
-    def get_bearer_token(self) -> str:
-        token = self.create_azure_credential().get_token(*self.scopes).token
-        return token
-
-
 @dataclass
 class AzureOpenAIClientConfig:
     """Parses configuration for Azure OpenAI client, resolves aliases and
@@ -547,13 +80,11 @@ class AzureOpenAIClientConfig:
     # 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
 
-    # OAuth related parameters
-    oauth: Optional[AzureOAuthConfig] = None
-
     extra_parameters: dict = field(default_factory=dict)
 
     def __post_init__(self) -> None:
@@ -575,7 +106,7 @@ class AzureOpenAIClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> AzureOpenAIClientConfig:
+    def from_dict(cls, config: dict) -> "AzureOpenAIClientConfig":
         """Initializes a dataclass from the passed config.
 
         Args:
@@ -598,26 +129,6 @@ class AzureOpenAIClientConfig:
         # Validate that the forbidden keys are not present
         validate_forbidden_keys(config, FORBIDDEN_KEYS)
         # Init client config
-
-        has_api_key = config.get(API_KEY, None) is not None
-        has_oauth_key = config.get(AZURE_OAUTH_KEY, None) is not None
-
-        if has_api_key and has_oauth_key:
-            message = (
-                "Azure OpenAI client configuration cannot contain "
-                "both 'api_key' and 'oauth' fields. Please provide either "
-                "'api_key' or 'oauth' fields."
-            )
-            structlogger.error(
-                "azure_openai_client_config.multiple_auth_types_specified",
-                message=message,
-            )
-            raise ValueError(message)
-
-        oauth = None
-        if has_oauth_key:
-            oauth = AzureOAuthConfig.from_config(config.pop(AZURE_OAUTH_KEY))
-
         this = AzureOpenAIClientConfig(
             # Required parameters
             deployment=config.pop(DEPLOYMENT_CONFIG_KEY),
@@ -631,8 +142,6 @@ class AzureOpenAIClientConfig:
             # in clients.
             api_base=config.pop(API_BASE_CONFIG_KEY, None),
             api_version=config.pop(API_VERSION_CONFIG_KEY, None),
-            # OAuth related parameters, set only if auth_type is set to 'entra_id'
-            oauth=oauth,
             # The rest of parameters (e.g. model parameters) are considered
             # as extra parameters (this also includes timeout).
             extra_parameters=config,
@@ -645,9 +154,6 @@ class AzureOpenAIClientConfig:
         # Extra parameters should also be on the top level
         d.pop("extra_parameters", None)
         d.update(self.extra_parameters)
-
-        d.pop("oauth", None)
-        d.update({"oauth": self.oauth.to_dict()} if self.oauth else {})
         return d
 
     @staticmethod

rasa/shared/providers/_configs/client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from typing import Protocol, runtime_checkable
 
 
@@ -11,7 +9,7 @@ class ClientConfig(Protocol):
     """
 
     @classmethod
-    def from_dict(cls, config: dict) -> ClientConfig:
+    def from_dict(cls, config: dict) -> "ClientConfig":
         """
         Initializes the client config with the given configuration.
 

rasa/shared/providers/_configs/default_litellm_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict
 
@@ -71,7 +69,7 @@ class DefaultLiteLLMClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> DefaultLiteLLMClientConfig:
+    def from_dict(cls, config: dict) -> "DefaultLiteLLMClientConfig":
         """
         Initializes a dataclass from the passed config.
 

rasa/shared/providers/_configs/huggingface_local_embedding_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, Optional
 
@@ -92,7 +90,7 @@ class HuggingFaceLocalEmbeddingClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> HuggingFaceLocalEmbeddingClientConfig:
+    def from_dict(cls, config: dict) -> "HuggingFaceLocalEmbeddingClientConfig":
         """
         Initializes a dataclass from the passed config.
 

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import copy
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
@@ -122,7 +120,7 @@ class LiteLLMRouterClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> LiteLLMRouterClientConfig:
+    def from_dict(cls, config: dict) -> "LiteLLMRouterClientConfig":
         """Initializes a dataclass from the passed config.
 
         Args:

rasa/shared/providers/_configs/model_group_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import List, Optional
 
@@ -18,9 +16,6 @@ from rasa.shared.constants import (
     MODELS_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
 )
-from rasa.shared.providers._configs._lite_llm_config.lite_llm_config_adapter import (
-    to_lite_llm_config,
-)
 from rasa.shared.providers.mappings import get_client_config_class_from_provider
 
 structlogger = structlog.get_logger()
@@ -46,7 +41,7 @@ class ModelConfig:
     api_type: Optional[str] = None
 
     @classmethod
-    def from_dict(cls, config: dict) -> ModelConfig:
+    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.
@@ -136,7 +131,7 @@ class ModelGroupConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> ModelGroupConfig:
+    def from_dict(cls, config: dict) -> "ModelGroupConfig":
         """Initializes a dataclass from the passed config.
 
         Args:

rasa/shared/providers/_configs/openai_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, Optional
 
@@ -113,7 +111,7 @@ class OpenAIClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> OpenAIClientConfig:
+    def from_dict(cls, config: dict) -> "OpenAIClientConfig":
         """
         Initializes a dataclass from the passed config.
 

rasa/shared/providers/_configs/rasa_llm_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import Optional
 
@@ -39,7 +37,7 @@ class RasaLLMClientConfig:
     extra_parameters: dict = field(default_factory=dict)
 
     @classmethod
-    def from_dict(cls, config: dict) -> RasaLLMClientConfig:
+    def from_dict(cls, config: dict) -> "RasaLLMClientConfig":
         """
         Initializes a dataclass from the passed config.
 

rasa/shared/providers/_configs/self_hosted_llm_client_config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, Optional
 
@@ -115,7 +113,7 @@ class SelfHostedLLMClientConfig:
             raise ValueError(message)
 
     @classmethod
-    def from_dict(cls, config: dict) -> SelfHostedLLMClientConfig:
+    def from_dict(cls, config: dict) -> "SelfHostedLLMClientConfig":
         """
         Initializes a dataclass from the passed config.
 

rasa/shared/providers/_configs/utils.py

@@ -1,4 +1,5 @@
 import structlog
+
 from rasa.shared.utils.io import raise_deprecation_warning
 
 structlogger = structlog.get_logger()