rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a2__py3-none-any.whl

rasa/shared/providers/embedding/litellm_router_embedding_client.py

@@ -1,135 +0,0 @@
-from typing import Any, Dict, List
-import logging
-import structlog
-
-from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.providers._configs.litellm_router_client_config import (
-    LiteLLMRouterClientConfig,
-)
-from rasa.shared.providers.embedding._base_litellm_embedding_client import (
-    _BaseLiteLLMEmbeddingClient,
-)
-from rasa.shared.providers.embedding.embedding_response import EmbeddingResponse
-from rasa.shared.providers.router._base_litellm_router_client import (
-    _BaseLiteLLMRouterClient,
-)
-from rasa.shared.utils.io import suppress_logs
-
-structlogger = structlog.get_logger()
-
-
-class LiteLLMRouterEmbeddingClient(
-    _BaseLiteLLMRouterClient, _BaseLiteLLMEmbeddingClient
-):
-    """A client for interfacing with LiteLLM Router Embedding endpoints.
-
-    Parameters:
-        model_group_id (str): The model group ID.
-        model_configurations (List[Dict[str, Any]]): The list of model configurations.
-        router_settings (Dict[str, Any]): The router settings.
-        kwargs (Optional[Dict[str, Any]]): Additional configuration parameters.
-
-    Raises:
-        ProviderClientValidationError: If validation of the client setup fails.
-    """
-
-    def __init__(
-        self,
-        model_group_id: str,
-        model_configurations: List[Dict[str, Any]],
-        router_settings: Dict[str, Any],
-        **kwargs: Any,
-    ):
-        super().__init__(
-            model_group_id, model_configurations, router_settings, **kwargs
-        )
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "LiteLLMRouterEmbeddingClient":
-        """Instantiates a LiteLLM Router Embedding client from a configuration dict.
-
-        Args:
-            config: (Dict[str, Any]) The configuration dictionary.
-
-        Returns:
-            LiteLLMRouterLLMClient: The instantiated LiteLLM Router LLM client.
-
-        Raises:
-            ValueError: If the configuration is invalid.
-        """
-        try:
-            client_config = LiteLLMRouterClientConfig.from_dict(config)
-        except (KeyError, ValueError) as e:
-            message = "Cannot instantiate a client from the passed configuration."
-            structlogger.error(
-                "litellm_router_llm_client.from_config.error",
-                message=message,
-                config=config,
-                original_error=e,
-            )
-            raise
-
-        return cls(
-            model_group_id=client_config.model_group_id,
-            model_configurations=client_config.litellm_model_list,
-            router_settings=client_config.litellm_router_settings,
-            **client_config.extra_parameters,
-        )
-
-    @suppress_logs(log_level=logging.WARNING)
-    def embed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents synchronously.
-
-        Args:
-            documents: List of documents to be embedded.
-
-        Returns:
-            List of embedding vectors.
-
-        Raises:
-            ProviderClientAPIException: If API calls raised an error.
-        """
-        self.validate_documents(documents)
-        try:
-            response = self.router_client.embedding(
-                input=documents, **self._embedding_fn_args
-            )
-            return self._format_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(
-                message="Failed to embed documents", original_exception=e
-            )
-
-    @suppress_logs(log_level=logging.WARNING)
-    async def aembed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents asynchronously.
-
-        Args:
-            documents: List of documents to be embedded.
-
-        Returns:
-            List of embedding vectors.
-
-        Raises:
-            ProviderClientAPIException: If API calls raised an error.
-        """
-        self.validate_documents(documents)
-        try:
-            response = await self.router_client.aembedding(
-                input=documents, **self._embedding_fn_args
-            )
-            return self._format_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(
-                message="Failed to embed documents", original_exception=e
-            )
-
-    @property
-    def _embedding_fn_args(self) -> Dict[str, Any]:
-        """Returns the arguments to be passed to the embedding function."""
-        return {
-            **self._litellm_extra_parameters,
-            "model": self._model_group_id,
-        }

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -1,182 +0,0 @@
-from typing import Any, Dict, List, Union
-import logging
-import structlog
-
-from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.providers._configs.litellm_router_client_config import (
-    LiteLLMRouterClientConfig,
-)
-from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
-from rasa.shared.providers.llm.llm_response import LLMResponse
-from rasa.shared.providers.router._base_litellm_router_client import (
-    _BaseLiteLLMRouterClient,
-)
-from rasa.shared.utils.io import suppress_logs
-
-structlogger = structlog.get_logger()
-
-
-class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
-    """A client for interfacing with LiteLLM Router LLM endpoints.
-
-    Parameters:
-        model_group_id (str): The model group ID.
-        model_configurations (List[Dict[str, Any]]): The list of model configurations.
-        router_settings (Dict[str, Any]): The router settings.
-        kwargs (Optional[Dict[str, Any]]): Additional configuration parameters.
-
-    Raises:
-        ProviderClientValidationError: If validation of the client setup fails.
-    """
-
-    def __init__(
-        self,
-        model_group_id: str,
-        model_configurations: List[Dict[str, Any]],
-        router_settings: Dict[str, Any],
-        **kwargs: Any,
-    ):
-        super().__init__(
-            model_group_id, model_configurations, router_settings, **kwargs
-        )
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "LiteLLMRouterLLMClient":
-        """Instantiates a LiteLLM Router LLM client from a configuration dict.
-
-        Args:
-            config: (Dict[str, Any]) The configuration dictionary.
-
-        Returns:
-            LiteLLMRouterLLMClient: The instantiated LiteLLM Router LLM client.
-
-        Raises:
-            ValueError: If the configuration is invalid.
-        """
-        try:
-            client_config = LiteLLMRouterClientConfig.from_dict(config)
-        except (KeyError, ValueError) as e:
-            message = "Cannot instantiate a client from the passed configuration."
-            structlogger.error(
-                "litellm_router_llm_client.from_config.error",
-                message=message,
-                config=config,
-                original_error=e,
-            )
-            raise
-
-        return cls(
-            model_group_id=client_config.model_group_id,
-            model_configurations=client_config.litellm_model_list,
-            router_settings=client_config.litellm_router_settings,
-            use_chat_completions_endpoint=client_config.use_chat_completions_endpoint,
-            **client_config.extra_parameters,
-        )
-
-    @suppress_logs(log_level=logging.WARNING)
-    def _text_completion(self, prompt: Union[List[str], str]) -> LLMResponse:
-        """
-        Synchronously generate completions for given prompt.
-
-        Args:
-            prompt: Prompt to generate the completion for.
-        Returns:
-            List of message completions.
-        Raises:
-            ProviderClientAPIException: If the API request fails.
-        """
-        try:
-            response = self.router_client.text_completion(
-                prompt=prompt, **self._completion_fn_args
-            )
-            return self._format_text_completion_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(e)
-
-    @suppress_logs(log_level=logging.WARNING)
-    async def _atext_completion(self, prompt: Union[List[str], str]) -> LLMResponse:
-        """
-        Asynchronously generate completions for given prompt.
-
-        Args:
-            prompt: Prompt to generate the completion for.
-        Returns:
-            List of message completions.
-        Raises:
-            ProviderClientAPIException: If the API request fails.
-        """
-        try:
-            response = await self.router_client.atext_completion(
-                prompt=prompt, **self._completion_fn_args
-            )
-            return self._format_text_completion_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(e)
-
-    @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """
-        Synchronously generate completions for given list of messages.
-
-        Method overrides the base class method to call the appropriate
-        completion method based on the configuration. If the chat completions
-        endpoint is enabled, the completion method is called. Otherwise, the
-        text_completion method is called.
-
-        Args:
-            messages: List of messages or a single message to generate the
-                completion for.
-        Returns:
-            List of message completions.
-        Raises:
-            ProviderClientAPIException: If the API request fails.
-        """
-        if not self._use_chat_completions_endpoint:
-            return self._text_completion(messages)
-        try:
-            formatted_messages = self._format_messages(messages)
-            response = self.router_client.completion(
-                messages=formatted_messages, **self._completion_fn_args
-            )
-            return self._format_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(e)
-
-    @suppress_logs(log_level=logging.WARNING)
-    async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """
-        Asynchronously generate completions for given list of messages.
-
-        Method overrides the base class method to call the appropriate
-        completion method based on the configuration. If the chat completions
-        endpoint is enabled, the completion method is called. Otherwise, the
-        text_completion method is called.
-
-        Args:
-            messages: List of messages or a single message to generate the
-                completion for.
-        Returns:
-            List of message completions.
-        Raises:
-            ProviderClientAPIException: If the API request fails.
-        """
-        if not self._use_chat_completions_endpoint:
-            return await self._atext_completion(messages)
-        try:
-            formatted_messages = self._format_messages(messages)
-            response = await self.router_client.acompletion(
-                messages=formatted_messages, **self._completion_fn_args
-            )
-            return self._format_response(response)
-        except Exception as e:
-            raise ProviderClientAPIException(e)
-
-    @property
-    def _completion_fn_args(self) -> Dict[str, Any]:
-        """Returns the completion arguments for invoking a call through
-        LiteLLM's completion functions.
-        """
-        return {
-            **self._litellm_extra_parameters,
-            "model": self.model_group_id,
-        }

rasa/shared/providers/llm/rasa_llm_client.py

@@ -1,112 +0,0 @@
-from typing import Any, Dict, Optional
-
-import structlog
-
-from rasa.shared.constants import (
-    RASA_PROVIDER,
-    OPENAI_PROVIDER,
-)
-from rasa.shared.providers._configs.rasa_llm_client_config import (
-    RasaLLMClientConfig,
-)
-from rasa.utils.licensing import retrieve_license_from_env
-from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
-
-
-structlogger = structlog.get_logger()
-
-
-class RasaLLMClient(_BaseLiteLLMClient):
-    """A client for interfacing with a Rasa-Hosted LLM endpoint that uses
-
-    Parameters:
-        model (str): The model or deployment name.
-        api_base (str): The base URL of the API endpoint.
-        kwargs: Any: Additional configuration parameters that can include, but
-            are not limited to model parameters and lite-llm specific
-            parameters. These parameters will be passed to the
-            completion/acompletion calls. To see what it can include, visit:
-
-    Raises:
-        ProviderClientValidationError: If validation of the client setup fails.
-        ProviderClientAPIException: If the API request fails.
-    """
-
-    def __init__(
-        self,
-        model: str,
-        api_base: str,
-        **kwargs: Any,
-    ):
-        super().__init__()  # type: ignore
-        self._model = model
-        self._api_base = api_base
-        self._use_chat_completions_endpoint = True
-        self._extra_parameters = kwargs or {}
-
-    @property
-    def model(self) -> str:
-        return self._model
-
-    @property
-    def api_base(self) -> Optional[str]:
-        """
-        Returns the base API URL for the openai llm client.
-        """
-        return self._api_base
-
-    @property
-    def provider(self) -> str:
-        """
-        Returns the provider name for the self hosted llm client.
-
-        Returns:
-            String representing the provider name.
-        """
-        return RASA_PROVIDER
-
-    @property
-    def _litellm_model_name(self) -> str:
-        return f"{OPENAI_PROVIDER}/{self._model}"
-
-    @property
-    def _litellm_extra_parameters(self) -> Dict[str, Any]:
-        return self._extra_parameters
-
-    @property
-    def config(self) -> dict:
-        return RasaLLMClientConfig(
-            model=self._model,
-            api_base=self._api_base,
-            extra_parameters=self._extra_parameters,
-        ).to_dict()
-
-    @property
-    def _completion_fn_args(self) -> Dict[str, Any]:
-        """Returns the completion arguments for invoking a call through
-        LiteLLM's completion functions.
-        """
-        fn_args = super()._completion_fn_args
-        fn_args.update(
-            {"api_base": self.api_base, "api_key": retrieve_license_from_env()}
-        )
-        return fn_args
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "RasaLLMClient":
-        try:
-            client_config = RasaLLMClientConfig.from_dict(config)
-        except ValueError as e:
-            message = "Cannot instantiate a client from the passed configuration."
-            structlogger.error(
-                "rasa_llm_client.from_config.error",
-                message=message,
-                config=config,
-                original_error=e,
-            )
-            raise
-        return cls(
-            model=client_config.model,
-            api_base=client_config.api_base,
-            **client_config.extra_parameters,
-        )

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -1,183 +0,0 @@
-from typing import Any, Dict, List
-import os
-import structlog
-
-from litellm import Router
-
-from rasa.shared.constants import (
-    MODEL_LIST_KEY,
-    MODEL_GROUP_ID_CONFIG_KEY,
-    ROUTER_CONFIG_KEY,
-    SELF_HOSTED_VLLM_PREFIX,
-    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
-    LITELLM_PARAMS_KEY,
-    API_KEY,
-    MODEL_CONFIG_KEY,
-    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
-)
-from rasa.shared.exceptions import ProviderClientValidationError
-from rasa.shared.providers._configs.litellm_router_client_config import (
-    LiteLLMRouterClientConfig,
-)
-from rasa.shared.utils.io import resolve_environment_variables
-
-structlogger = structlog.get_logger()
-
-
-class _BaseLiteLLMRouterClient:
-    """An abstract base class for LiteLLM Router clients.
-
-    This class defines the interface and common functionality for all the router clients
-    based on LiteLLM.
-
-    The class is made private to prevent it from being part of the public-facing
-    interface, as it serves as an internal base class for specific implementations of
-    router clients that are based on LiteLLM router implementation.
-
-    Parameters:
-        model_group_id (str): The model group ID.
-        model_configurations (List[Dict[str, Any]]): The list of model configurations.
-        router_settings (Dict[str, Any]): The router settings.
-        kwargs (Optional[Dict[str, Any]]): Additional configuration parameters.
-
-    Raises:
-        ProviderClientValidationError: If validation of the client setup fails.
-    """
-
-    def __init__(
-        self,
-        model_group_id: str,
-        model_configurations: List[Dict[str, Any]],
-        router_settings: Dict[str, Any],
-        use_chat_completions_endpoint: bool = True,
-        **kwargs: Any,
-    ):
-        self._model_group_id = model_group_id
-        self._model_configurations = model_configurations
-        self._router_settings = router_settings
-        self._use_chat_completions_endpoint = use_chat_completions_endpoint
-        self._extra_parameters = kwargs or {}
-        self.additional_client_setup()
-        try:
-            resolved_model_configurations = (
-                self._resolve_env_vars_in_model_configurations()
-            )
-            self._router_client = Router(
-                model_list=resolved_model_configurations, **router_settings
-            )
-        except Exception as e:
-            event_info = "Cannot instantiate a router client."
-            structlogger.error(
-                "_base_litellm_router_client.init.error",
-                event_info=event_info,
-                model_group_id=model_group_id,
-                models=model_configurations,
-                router=router_settings,
-                original_error=e,
-            )
-            raise ProviderClientValidationError(f"{event_info} Original error: {e}")
-
-    def additional_client_setup(self) -> None:
-        """Additional setup for the LiteLLM Router client."""
-        # If the model configuration is self-hosted VLLM, set a dummy API key if not
-        # provided. A bug in the LiteLLM library requires an API key to be set even if
-        # it is not required.
-        for model_configuration in self.model_configurations:
-            if (
-                f"{SELF_HOSTED_VLLM_PREFIX}/"
-                in model_configuration[LITELLM_PARAMS_KEY][MODEL_CONFIG_KEY]
-                and API_KEY not in model_configuration[LITELLM_PARAMS_KEY]
-                and not os.getenv(SELF_HOSTED_VLLM_API_KEY_ENV_VAR)
-            ):
-                os.environ[SELF_HOSTED_VLLM_API_KEY_ENV_VAR] = "dummy api key"
-                return
-
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "_BaseLiteLLMRouterClient":
-        """Instantiates a LiteLLM Router Embedding client from a configuration dict.
-
-        Args:
-            config: (Dict[str, Any]) The configuration dictionary.
-
-        Returns:
-            LiteLLMRouterLLMClient: The instantiated LiteLLM Router LLM client.
-
-        Raises:
-            ValueError: If the configuration is invalid.
-        """
-        try:
-            client_config = LiteLLMRouterClientConfig.from_dict(config)
-        except (KeyError, ValueError) as e:
-            message = "Cannot instantiate a client from the passed configuration."
-            structlogger.error(
-                "litellm_router_llm_client.from_config.error",
-                message=message,
-                config=config,
-                original_error=e,
-            )
-            raise
-
-        return cls(
-            model_group_id=client_config.model_group_id,
-            model_configurations=client_config.litellm_model_list,
-            router_settings=client_config.litellm_router_settings,
-            use_chat_completions_endpoint=client_config.use_chat_completions_endpoint,
-            **client_config.extra_parameters,
-        )
-
-    @property
-    def model_group_id(self) -> str:
-        """Returns the model group ID for the LiteLLM Router client."""
-        return self._model_group_id
-
-    @property
-    def model_configurations(self) -> List[Dict[str, Any]]:
-        """Returns the model configurations for the LiteLLM Router client."""
-        return self._model_configurations
-
-    @property
-    def router_settings(self) -> Dict[str, Any]:
-        """Returns the router settings for the LiteLLM Router client."""
-        return self._router_settings
-
-    @property
-    def router_client(self) -> Router:
-        """Returns the instantiated LiteLLM Router client."""
-        return self._router_client
-
-    @property
-    def use_chat_completions_endpoint(self) -> bool:
-        """Returns whether to use the chat completions endpoint."""
-        return self._use_chat_completions_endpoint
-
-    @property
-    def _litellm_extra_parameters(self) -> Dict[str, Any]:
-        """
-        Returns the extra parameters for the LiteLLM Router client.
-
-        Returns:
-            Dictionary containing the model parameters.
-        """
-        return self._extra_parameters
-
-    @property
-    def config(self) -> Dict:
-        """Returns the configuration for the LiteLLM Router client in LiteLLM format."""
-        return {
-            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
-            MODEL_LIST_KEY: self.model_configurations,
-            ROUTER_CONFIG_KEY: self.router_settings,
-            USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY: (
-                self.use_chat_completions_endpoint
-            ),
-            **self._litellm_extra_parameters,
-        }
-
-    def _resolve_env_vars_in_model_configurations(self) -> List:
-        model_configuration_with_resolved_keys = []
-        for model_configuration in self.model_configurations:
-            resolved_model_configuration = resolve_environment_variables(
-                model_configuration
-            )
-            model_configuration_with_resolved_keys.append(resolved_model_configuration)
-        return model_configuration_with_resolved_keys

rasa/shared/providers/router/router_client.py

@@ -1,73 +0,0 @@
-from typing import Any, Dict, List, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class RouterClient(Protocol):
-    """
-    Protocol for a Router client that specifies the interface for interacting
-    with the API.
-    """
-
-    @classmethod
-    def from_config(cls, config: dict) -> "RouterClient":
-        """
-        Initializes the router client with the given configuration.
-
-        This class method should be implemented to parse the given
-        configuration and create an instance of an router client.
-        """
-        ...
-
-    @property
-    def config(self) -> Dict:
-        """
-        Returns the configuration for that the router client is initialized with.
-
-        This property should be implemented to return a dictionary containing
-        the client configuration settings for the router client.
-        """
-        ...
-
-    @property
-    def router_settings(self) -> Dict[str, Any]:
-        """
-        Returns the router settings for the Router client.
-
-        This property should be implemented to return a dictionary containing
-        the router settings for the router client.
-        """
-        ...
-
-    @property
-    def model_group_id(self) -> str:
-        """
-        Returns the model group ID for the Router client.
-
-        This property should be implemented to return the model group ID
-        for the router client.
-        """
-        ...
-
-    @property
-    def model_configurations(self) -> List[Dict[str, Any]]:
-        """
-        Returns the list of model configurations for the Router client.
-
-        This property should be implemented to return the list of model configurations
-        for the router client as a list of dictionaries.
-
-        Each dictionary should contain the model configuration.
-        Ideally, the `ModelGroupConfig` should parse the model configurations
-        and generate this list of dictionaries.
-        """
-        ...
-
-    @property
-    def router_client(self) -> object:
-        """
-        Returns the instantiated Router client.
-
-        This property should be implemented to return the instantiated
-        Router client.
-        """
-        ...