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

rasa/model_service.py

@@ -1,112 +0,0 @@
-import logging
-
-from sanic import Sanic
-import structlog
-
-from rasa.cli.scaffold import print_error_and_exit
-from rasa.core.persistor import RemoteStorageType, get_persistor
-from rasa.core.utils import list_routes
-from rasa.model_manager import model_api
-from rasa.model_manager import config
-from rasa.model_manager.config import SERVER_BASE_URL, SERVER_PORT
-from rasa.utils.common import configure_logging_and_warnings
-import rasa.utils.licensing
-from urllib.parse import urlparse
-
-from rasa.utils.log_utils import configure_structlog
-from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
-
-structlogger = structlog.get_logger()
-
-
-def url_prefix_from_base_url() -> str:
-    """Return the path prefix from the base URL."""
-    # return path without any trailing slashes
-    prefix = urlparse(SERVER_BASE_URL).path.rstrip("/") if SERVER_BASE_URL else ""
-
-    # can't be empty
-    return prefix or config.DEFAULT_SERVER_PATH_PREFIX
-
-
-def validate_model_storage_type() -> None:
-    """Validate the storage type if remote storage is used for models."""
-    if config.SERVER_MODEL_REMOTE_STORAGE:
-        if config.SERVER_MODEL_REMOTE_STORAGE not in RemoteStorageType.list():
-            print_error_and_exit(
-                f"Invalid storage type '{config.SERVER_MODEL_REMOTE_STORAGE}'. "
-                f"Supported storage types: {', '.join(RemoteStorageType.list())}."
-                f"Alternatively, unset the remote storage type to store models locally."
-            )
-        else:
-            structlogger.info(
-                "model_api.storage.remote_storage_enabled",
-                remote_storage=config.SERVER_MODEL_REMOTE_STORAGE,
-            )
-        # try to create a client to validate the configuration
-        get_persistor(config.SERVER_MODEL_REMOTE_STORAGE)
-    else:
-        structlogger.info(
-            "model_api.storage.local_storage_enabled",
-            base_path=config.SERVER_BASE_WORKING_DIRECTORY,
-        )
-
-
-def _register_update_task(app: Sanic) -> None:
-    app.add_task(
-        model_api.continuously_update_process_status,
-        name="continuously_update_process_status",
-    )
-
-
-def main() -> None:
-    """Start the Rasa Model Manager server.
-
-    The API server can receive requests to train models, run bots, and manage
-    the lifecycle of models and bots.
-    """
-    log_level = logging.DEBUG
-    configure_logging_and_warnings(
-        log_level=log_level,
-        logging_config_file=None,
-        warn_only_once=True,
-        filter_repeated_logs=True,
-    )
-    configure_structlog(log_level, include_time=True)
-
-    rasa.utils.licensing.validate_license_from_env()
-
-    try:
-        model_api.prepare_working_directories()
-    except Exception as e:
-        structlogger.error(
-            "model_api.prepare_directories.failed",
-            error=str(e),
-            base_directory=config.SERVER_BASE_WORKING_DIRECTORY,
-        )
-        print_error_and_exit(
-            f"Failed to create working directories. Please make sure the "
-            f"server base directory at '{config.SERVER_BASE_WORKING_DIRECTORY}' "
-            f"is writable by the current user."
-        )
-
-    validate_model_storage_type()
-
-    structlogger.debug("model_api.starting_server", port=SERVER_PORT)
-
-    url_prefix = url_prefix_from_base_url()
-    # configure the sanic application
-    app = Sanic("RasaModelService")
-    app.after_server_start(_register_update_task)
-    app.blueprint(model_api.external_blueprint(), url_prefix=url_prefix)
-    app.blueprint(model_api.internal_blueprint())
-
-    # list all routes
-    list_routes(app)
-
-    register_custom_sanic_error_handler(app)
-
-    app.run(host="0.0.0.0", port=SERVER_PORT, legacy=True, motd=False)
-
-
-if __name__ == "__main__":
-    main()

rasa/shared/core/flows/utils.py

@@ -1,39 +0,0 @@
-from typing import Set
-from rasa.shared.utils.io import raise_deprecation_warning
-
-RESET_PROPERTY_NAME = "reset_after_flow_ends"
-PERSIST_PROPERTY_NAME = "persisted_slots"
-
-
-def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
-    """Warns about deprecated reset_after_flow_ends usage in collect steps."""
-    raise_deprecation_warning(
-        f"Configuring '{RESET_PROPERTY_NAME}' in collect step '{collect_step}' is "
-        f"deprecated and will be removed in Rasa Pro 4.0.0. In flow id '{flow_id}', "
-        f"please use the '{PERSIST_PROPERTY_NAME}' "
-        "property at the flow level instead."
-    )
-
-
-def get_duplicate_slot_persistence_config_error_message(
-    flow_id: str, collect_step: str
-) -> str:
-    """Returns an error message for duplicate slot persistence configuration."""
-    return (
-        f"Flow with id '{flow_id}' uses the '{RESET_PROPERTY_NAME}' property "
-        f"in collect step '{collect_step}' and also the "
-        f"'{PERSIST_PROPERTY_NAME}' property at the flow level. "
-        "Please use only one of the two configuration methods."
-    )
-
-
-def get_invalid_slot_persistence_config_error_message(
-    flow_id: str, invalid_slots: Set[str]
-) -> str:
-    """Returns an error message for invalid slot persistence configuration."""
-    return (
-        f"Flow with id '{flow_id}' lists slot(s) '{invalid_slots}' in the "
-        f"'{PERSIST_PROPERTY_NAME}' property. However these slots "
-        f"are neither used in a collect step nor a set_slot step of the flow. "
-        f"Please remove such slots from the '{PERSIST_PROPERTY_NAME}' property."
-    )

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -1,220 +0,0 @@
-import copy
-from dataclasses import dataclass, field
-from typing import Any, Dict, List
-
-import structlog
-from rasa.shared.constants import (
-    ROUTER_CONFIG_KEY,
-    MODELS_CONFIG_KEY,
-    MODEL_GROUP_ID_CONFIG_KEY,
-    MODEL_NAME_CONFIG_KEY,
-    LITELLM_PARAMS_KEY,
-    PROVIDER_CONFIG_KEY,
-    DEPLOYMENT_CONFIG_KEY,
-    API_TYPE_CONFIG_KEY,
-    MODEL_CONFIG_KEY,
-    MODEL_LIST_KEY,
-    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
-)
-from rasa.shared.providers._configs.model_group_config import (
-    ModelGroupConfig,
-    ModelConfig,
-)
-from rasa.shared.providers.mappings import get_prefix_from_provider
-from rasa.shared.utils.llm import DEPLOYMENT_CENTRIC_PROVIDERS
-
-
-structlogger = structlog.get_logger()
-
-_LITELLM_UNSUPPORTED_KEYS = [
-    PROVIDER_CONFIG_KEY,
-    DEPLOYMENT_CONFIG_KEY,
-    API_TYPE_CONFIG_KEY,
-    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
-]
-
-
-@dataclass
-class LiteLLMRouterClientConfig:
-    """Parses configuration for a LiteLLM Router client. The configuration is expected
-    to be in the following format:
-
-    {
-        "id": "model_group_id",
-        "models": [
-            {
-                "provider": "provider_name",
-                "model": "model_name",
-                "api_base": "api_base",
-                "api_key": "api_key",
-                "api_version": "api_version",
-            },
-            {
-                "provider": "provider_name",
-                "model": "model_name",
-            },
-        "router": {}
-    }
-
-    This configuration is converted into the LiteLLM required format:
-
-    {
-        "id": "model_group_id",
-        "model_list": [
-            {
-                "model_name": "model_group_id",
-                "litellm_params": {
-                    "model": "provider_name/model_name",
-                    "api_base": "api_base",
-                    "api_key": "api_key",
-                    "api_version": "api_version",
-                },
-            },
-            {
-                "model_name": "model_group_id",
-                "litellm_params": {
-                    "model": "provider_name/model_name",
-                },
-            },
-        ],
-        "router": {},
-    }
-
-    Raises:
-        ValueError: If the configuration is missing required keys.
-    """
-
-    _model_group_config: ModelGroupConfig
-    router: Dict[str, Any]
-    _use_chat_completions_endpoint: bool = True
-    extra_parameters: dict = field(default_factory=dict)
-
-    @property
-    def model_group_id(self) -> str:
-        return self._model_group_config.model_group_id
-
-    @property
-    def models(self) -> List[ModelConfig]:
-        return self._model_group_config.models
-
-    @property
-    def litellm_model_list(self) -> List[Dict[str, Any]]:
-        return self._convert_models_to_litellm_model_list()
-
-    @property
-    def litellm_router_settings(self) -> Dict[str, Any]:
-        return self._convert_router_to_litellm_router_settings()
-
-    @property
-    def use_chat_completions_endpoint(self) -> bool:
-        return self._use_chat_completions_endpoint
-
-    def __post_init__(self) -> None:
-        if not self.router:
-            message = "Router cannot be empty."
-            structlogger.error(
-                "litellm_router_client_config.validation_error",
-                message=message,
-                model_group_id=self._model_group_config.model_group_id,
-            )
-            raise ValueError(message)
-
-    @classmethod
-    def from_dict(cls, config: dict) -> "LiteLLMRouterClientConfig":
-        """Initializes a dataclass from the passed config.
-
-        Args:
-            config: (dict) The config from which to initialize.
-
-        Raises:
-            ValueError: Config is missing required keys.
-
-        Returns:
-            LiteLLMRouterClientConfig
-        """
-        model_group_config = ModelGroupConfig.from_dict(config)
-
-        # Copy config to avoid mutating the original
-        config_copy = copy.deepcopy(config)
-        # Pop the keys used by ModelGroupConfig
-        config_copy.pop(MODEL_GROUP_ID_CONFIG_KEY, None)
-        config_copy.pop(MODELS_CONFIG_KEY, None)
-        # Get the router settings
-        router_settings = config_copy.pop(ROUTER_CONFIG_KEY, {})
-        # Get the use_chat_completions_endpoint setting
-        use_chat_completions_endpoint = router_settings.get(
-            USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, True
-        )
-        # The rest is considered as extra parameters
-        extra_parameters = config_copy
-
-        this = LiteLLMRouterClientConfig(
-            _model_group_config=model_group_config,
-            router=router_settings,
-            _use_chat_completions_endpoint=use_chat_completions_endpoint,
-            extra_parameters=extra_parameters,
-        )
-        return this
-
-    def to_dict(self) -> dict:
-        """Converts the config instance into a dictionary."""
-        d = self._model_group_config.to_dict()
-        d[ROUTER_CONFIG_KEY] = self.router
-        if self.extra_parameters:
-            d.update(self.extra_parameters)
-        return d
-
-    def to_litellm_dict(self) -> dict:
-        return {
-            **self.extra_parameters,
-            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
-            MODEL_LIST_KEY: self._convert_models_to_litellm_model_list(),
-            ROUTER_CONFIG_KEY: self._convert_router_to_litellm_router_settings(),
-        }
-
-    def _convert_router_to_litellm_router_settings(self) -> Dict[str, Any]:
-        _router_settings_copy = copy.deepcopy(self.router)
-        _router_settings_copy.pop(USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, None)
-        return _router_settings_copy
-
-    def _convert_models_to_litellm_model_list(self) -> List[Dict[str, Any]]:
-        litellm_model_list = []
-
-        for model_config_object in self.models:
-            # Convert the model config to a dict representation
-            litellm_model_config = model_config_object.to_dict()
-
-            provider = litellm_model_config[PROVIDER_CONFIG_KEY]
-
-            # Get the litellm prefixing for the provider
-            prefix = get_prefix_from_provider(provider)
-
-            # Determine whether to use model or deployment key based on the provider.
-            litellm_model_name = (
-                litellm_model_config[DEPLOYMENT_CONFIG_KEY]
-                if provider in DEPLOYMENT_CENTRIC_PROVIDERS
-                else litellm_model_config[MODEL_CONFIG_KEY]
-            )
-
-            # Set 'model' to a provider prefixed model name e.g. openai/gpt-4
-            litellm_model_config[MODEL_CONFIG_KEY] = (
-                litellm_model_name
-                if f"{prefix}/" in litellm_model_name
-                else f"{prefix}/{litellm_model_name}"
-            )
-
-            # Remove parameters that are None and not supported by LiteLLM.
-            litellm_model_config = {
-                key: value
-                for key, value in litellm_model_config.items()
-                if key not in _LITELLM_UNSUPPORTED_KEYS and value is not None
-            }
-
-            litellm_model_list_item = {
-                MODEL_NAME_CONFIG_KEY: self.model_group_id,
-                LITELLM_PARAMS_KEY: litellm_model_config,
-            }
-
-            litellm_model_list.append(litellm_model_list_item)
-
-        return litellm_model_list

rasa/shared/providers/_configs/model_group_config.py

@@ -1,167 +0,0 @@
-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/rasa_llm_client_config.py

@@ -1,73 +0,0 @@
-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/_utils.py

@@ -1,79 +0,0 @@
-import structlog
-
-from rasa.shared.constants import (
-    AWS_ACCESS_KEY_ID_ENV_VAR,
-    AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_SECRET_ACCESS_KEY_ENV_VAR,
-    AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-    AWS_REGION_NAME_ENV_VAR,
-    AWS_REGION_NAME_CONFIG_KEY,
-    AWS_SESSION_TOKEN_CONFIG_KEY,
-    AWS_SESSION_TOKEN_ENV_VAR,
-)
-from rasa.shared.exceptions import ProviderClientValidationError
-from litellm import validate_environment
-from rasa.shared.providers.embedding._base_litellm_embedding_client import (
-    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
-)
-
-structlogger = structlog.get_logger()
-
-
-def validate_aws_setup_for_litellm_clients(
-    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
-) -> None:
-    """Validates the AWS setup for LiteLLM clients to ensure all required
-    environment variables or corresponding call kwargs are set.
-
-    Args:
-        litellm_model_name (str): The name of the LiteLLM model being validated.
-        litellm_call_kwargs (dict): Additional keyword arguments passed to the client,
-            which may include configuration values for AWS credentials.
-        source_log (str): The source log identifier for structured logging.
-
-    Raises:
-        ProviderClientValidationError: If any required AWS environment variable
-            or corresponding configuration key is missing.
-    """
-
-    # Mapping of environment variable names to their corresponding config keys
-    envs_to_args = {
-        AWS_ACCESS_KEY_ID_ENV_VAR: AWS_ACCESS_KEY_ID_CONFIG_KEY,
-        AWS_SECRET_ACCESS_KEY_ENV_VAR: AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-        AWS_REGION_NAME_ENV_VAR: AWS_REGION_NAME_CONFIG_KEY,
-        AWS_SESSION_TOKEN_ENV_VAR: AWS_SESSION_TOKEN_CONFIG_KEY,
-    }
-
-    # Validate the environment setup for the model
-    validation_info = validate_environment(litellm_model_name)
-    missing_environment_variables = validation_info.get(
-        _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY, []
-    )
-    # Filter out missing environment variables that have been set trough arguments
-    # in extra parameters
-    missing_environment_variables = [
-        missing_env_var
-        for missing_env_var in missing_environment_variables
-        if litellm_call_kwargs.get(envs_to_args.get(missing_env_var)) is None
-    ]
-
-    if missing_environment_variables:
-        missing_environment_details = [
-            (
-                f"'{missing_env_var}' environment variable or "
-                f"'{envs_to_args.get(missing_env_var)}' config key"
-            )
-            for missing_env_var in missing_environment_variables
-        ]
-        event_info = (
-            f"The following environment variables or configuration keys are "
-            f"missing: "
-            f"{', '.join(missing_environment_details)}. "
-            f"These settings are required for API calls."
-        )
-        structlogger.error(
-            f"{source_log}.validate_aws_environment_variables",
-            event_info=event_info,
-            missing_environment_variables=missing_environment_variables,
-        )
-        raise ProviderClientValidationError(event_info)