rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc1__py3-none-any.whl

rasa/shared/nlu/training_data/features.py

@@ -1,15 +1,133 @@
 from __future__ import annotations
-from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
+
 import itertools
+from dataclasses import dataclass
+from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
 
 import numpy as np
 import scipy.sparse
+from safetensors.numpy import save_file, load_file
 
-import rasa.shared.utils.io
 import rasa.shared.nlu.training_data.util
+import rasa.shared.utils.io
 from rasa.shared.nlu.constants import FEATURE_TYPE_SEQUENCE, FEATURE_TYPE_SENTENCE
 
 
+@dataclass
+class FeatureMetadata:
+    data_type: str
+    attribute: str
+    origin: Union[str, List[str]]
+    is_sparse: bool
+    shape: tuple
+    safetensors_key: str
+
+
+def save_features(
+    features_dict: Dict[Text, List[Features]], file_name: str
+) -> Dict[str, Any]:
+    """Save a dictionary of Features lists to disk using safetensors.
+
+    Args:
+        features_dict: Dictionary mapping strings to lists of Features objects
+        file_name: File to save the features to
+
+    Returns:
+        The metadata to reconstruct the features.
+    """
+    # All tensors are stored in a single safetensors file
+    tensors_to_save = {}
+    # Metadata will be stored separately
+    metadata = {}
+
+    for key, features_list in features_dict.items():
+        feature_metadata_list = []
+
+        for idx, feature in enumerate(features_list):
+            # Create a unique key for this tensor in the safetensors file
+            safetensors_key = f"{key}_{idx}"
+
+            # Convert sparse matrices to dense if needed
+            if feature.is_sparse():
+                # For sparse matrices, use the COO format
+                coo = feature.features.tocoo()  # type:ignore[union-attr]
+                # Save data, row indices and col indices separately
+                tensors_to_save[f"{safetensors_key}_data"] = coo.data
+                tensors_to_save[f"{safetensors_key}_row"] = coo.row
+                tensors_to_save[f"{safetensors_key}_col"] = coo.col
+            else:
+                tensors_to_save[safetensors_key] = feature.features
+
+            # Store metadata
+            metadata_item = FeatureMetadata(
+                data_type=feature.type,
+                attribute=feature.attribute,
+                origin=feature.origin,
+                is_sparse=feature.is_sparse(),
+                shape=feature.features.shape,
+                safetensors_key=safetensors_key,
+            )
+            feature_metadata_list.append(vars(metadata_item))
+
+        metadata[key] = feature_metadata_list
+
+    # Save tensors
+    save_file(tensors_to_save, file_name)
+
+    return metadata
+
+
+def load_features(
+    filename: str, metadata: Dict[str, Any]
+) -> Dict[Text, List[Features]]:
+    """Load Features dictionary from disk.
+
+    Args:
+        filename: File name of the safetensors file.
+        metadata: Metadata to reconstruct the features.
+
+    Returns:
+        Dictionary mapping strings to lists of Features objects
+    """
+    # Load tensors
+    tensors = load_file(filename)
+
+    # Reconstruct the features dictionary
+    features_dict: Dict[Text, List[Features]] = {}
+
+    for key, feature_metadata_list in metadata.items():
+        features_list = []
+
+        for meta in feature_metadata_list:
+            safetensors_key = meta["safetensors_key"]
+
+            if meta["is_sparse"]:
+                # Reconstruct sparse matrix from COO format
+                data = tensors[f"{safetensors_key}_data"]
+                row = tensors[f"{safetensors_key}_row"]
+                col = tensors[f"{safetensors_key}_col"]
+
+                features_matrix = scipy.sparse.coo_matrix(
+                    (data, (row, col)), shape=tuple(meta["shape"])
+                ).tocsr()  # Convert back to CSR format
+            else:
+                features_matrix = tensors[safetensors_key]
+
+            # Reconstruct Features object
+            features = Features(
+                features=features_matrix,
+                feature_type=meta["data_type"],
+                attribute=meta["attribute"],
+                origin=meta["origin"],
+            )
+
+            features_list.append(features)
+
+        features_dict[key] = features_list
+
+    return features_dict
+
+
 class Features:
     """Stores the features produced by any featurizer."""
 

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -107,8 +107,7 @@ class AzureOpenAIClientConfig:
 
     @classmethod
     def from_dict(cls, config: dict) -> "AzureOpenAIClientConfig":
-        """
-        Initializes a dataclass from the passed config.
+        """Initializes a dataclass from the passed config.
 
         Args:
             config: (dict) The config from which to initialize.
@@ -175,7 +174,10 @@ def is_azure_openai_config(config: dict) -> bool:
 
     # Case: Configuration contains `deployment` key
     # (specific to Azure OpenAI configuration)
-    if config.get(DEPLOYMENT_CONFIG_KEY) is not None:
+    if (
+        config.get(DEPLOYMENT_CONFIG_KEY) is not None
+        and config.get(PROVIDER_CONFIG_KEY) is None
+    ):
         return True
 
     return False

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -0,0 +1,200 @@
+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,
+)
+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,
+]
+
+
+@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]
+    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()
+
+    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, None)
+        # The rest is considered as extra parameters
+        extra_parameters = config_copy
+
+        this = LiteLLMRouterClientConfig(
+            _model_group_config=model_group_config,
+            router=router_settings,
+            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:
+        litellm_model_list = self._convert_models_to_litellm_model_list()
+        d = {
+            **self.extra_parameters,
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODEL_LIST_KEY: litellm_model_list,
+            ROUTER_CONFIG_KEY: self.router,
+        }
+        return d
+
+    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_without_prefix = (
+                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] = (
+                f"{prefix}/{litellm_model_name_without_prefix}"
+            )
+
+            # 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

rasa/shared/providers/_configs/openai_client_config.py

@@ -19,8 +19,8 @@ from rasa.shared.constants import (
     REQUEST_TIMEOUT_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
-    OPENAI_PROVIDER,
     OPENAI_API_TYPE,
+    OPENAI_PROVIDER,
 )
 from rasa.shared.providers._configs.utils import (
     resolve_aliases,

rasa/shared/providers/_configs/rasa_llm_client_config.py

@@ -0,0 +1,73 @@
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    RASA_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    validate_required_keys,
+)
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY, API_BASE_CONFIG_KEY]
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class RasaLLMClientConfig:
+    """Parses configuration for a Rasa Hosted LiteLLM client,
+    checks required keys present.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+    """
+
+    model: Optional[str]
+    api_base: Optional[str]
+    # Provider is not used by LiteLLM backend, but we define it here since it's
+    # used as switch between different clients.
+    provider: str = RASA_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "RasaLLMClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Raised in cases of invalid configuration:
+                - If any of the required configuration keys are missing.
+                - If `api_type` has a value different from `azure`.
+
+        Returns:
+            RasaLLMClientConfig
+        """
+        # Validate that required keys are set
+        validate_required_keys(config, REQUIRED_KEYS)
+
+        extra_parameters = {k: v for k, v in config.items() if k not in REQUIRED_KEYS}
+
+        return cls(
+            model=config.get(MODEL_CONFIG_KEY),
+            api_base=config.get(API_BASE_CONFIG_KEY),
+            provider=config.get(PROVIDER_CONFIG_KEY, RASA_PROVIDER),
+            extra_parameters=extra_parameters,
+        )
+
+    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

rasa/shared/providers/_configs/self_hosted_llm_client_config.py

@@ -23,6 +23,7 @@ from rasa.shared.constants import (
     SELF_HOSTED_PROVIDER,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
+
 from rasa.shared.providers._configs.utils import (
     raise_deprecation_warnings,
     resolve_aliases,

rasa/shared/providers/_configs/utils.py

@@ -99,3 +99,19 @@ def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
             config=config,
         )
         raise ValueError(message)
+
+
+def get_provider_prefixed_model_name(provider: str, model: str) -> str:
+    """
+    Returns the model name with the provider prefixed.
+
+    Args:
+        provider: The provider of the model.
+        model: The model name.
+
+    Returns:
+        The model name with the provider prefixed.
+    """
+    if model and f"{provider}/" not in model:
+        return f"{provider}/{model}"
+    return model