rasa-pro 3.10.16__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/shared/nlu/training_data/features.py

@@ -1,133 +1,15 @@
 from __future__ import annotations
-
-import itertools
-from dataclasses import dataclass
 from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
+import itertools
 
 import numpy as np
 import scipy.sparse
-from safetensors.numpy import save_file, load_file
 
-import rasa.shared.nlu.training_data.util
 import rasa.shared.utils.io
+import rasa.shared.nlu.training_data.util
 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/nlu/training_data/training_data.py

@@ -1,5 +1,6 @@
 import logging
 import os
+from functools import cached_property
 from pathlib import Path
 import random
 from collections import Counter, OrderedDict
@@ -9,7 +10,6 @@ from typing import Any, Dict, List, Optional, Set, Text, Tuple, Callable
 import operator
 
 import rasa.shared.data
-from rasa.shared.utils.common import lazy_property
 import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     RESPONSE,
@@ -202,7 +202,7 @@ class TrainingData:
 
         return list(OrderedDict.fromkeys(examples))
 
-    @lazy_property
+    @cached_property
     def nlu_examples(self) -> List[Message]:
         """Return examples which have come from NLU training data.
 
@@ -215,32 +215,32 @@ class TrainingData:
             ex for ex in self.training_examples if not ex.is_core_or_domain_message()
         ]
 
-    @lazy_property
+    @cached_property
     def intent_examples(self) -> List[Message]:
         """Returns the list of examples that have intent."""
         return [ex for ex in self.nlu_examples if ex.get(INTENT)]
 
-    @lazy_property
+    @cached_property
     def response_examples(self) -> List[Message]:
         """Returns the list of examples that have response."""
         return [ex for ex in self.nlu_examples if ex.get(INTENT_RESPONSE_KEY)]
 
-    @lazy_property
+    @cached_property
     def entity_examples(self) -> List[Message]:
         """Returns the list of examples that have entities."""
         return [ex for ex in self.nlu_examples if ex.get(ENTITIES)]
 
-    @lazy_property
+    @cached_property
     def intents(self) -> Set[Text]:
         """Returns the set of intents in the training data."""
         return {ex.get(INTENT) for ex in self.training_examples} - {None}
 
-    @lazy_property
+    @cached_property
     def action_names(self) -> Set[Text]:
         """Returns the set of action names in the training data."""
         return {ex.get(ACTION_NAME) for ex in self.training_examples} - {None}
 
-    @lazy_property
+    @cached_property
     def retrieval_intents(self) -> Set[Text]:
         """Returns the total number of response types in the training data."""
         return {
@@ -249,13 +249,13 @@ class TrainingData:
             if ex.get(INTENT_RESPONSE_KEY)
         }
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_intent(self) -> Dict[Text, int]:
         """Calculates the number of examples per intent."""
         intents = [ex.get(INTENT) for ex in self.nlu_examples]
         return dict(Counter(intents))
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_response(self) -> Dict[Text, int]:
         """Calculates the number of examples per response."""
         responses = [
@@ -265,12 +265,12 @@ class TrainingData:
         ]
         return dict(Counter(responses))
 
-    @lazy_property
+    @cached_property
     def entities(self) -> Set[Text]:
         """Returns the set of entity types in the training data."""
         return {e.get(ENTITY_ATTRIBUTE_TYPE) for e in self.sorted_entities()}
 
-    @lazy_property
+    @cached_property
     def entity_roles(self) -> Set[Text]:
         """Returns the set of entity roles in the training data."""
         entity_types = {
@@ -280,7 +280,7 @@ class TrainingData:
         }
         return entity_types - {NO_ENTITY_TAG}
 
-    @lazy_property
+    @cached_property
     def entity_groups(self) -> Set[Text]:
         """Returns the set of entity groups in the training data."""
         entity_types = {
@@ -299,7 +299,7 @@ class TrainingData:
 
         return entity_groups_used or entity_roles_used
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_entity(self) -> Dict[Text, int]:
         """Calculates the number of examples per entity."""
         entities = []
@@ -426,8 +426,9 @@ class TrainingData:
     def persist(
         self, dir_name: Text, filename: Text = DEFAULT_TRAINING_DATA_OUTPUT_PATH
     ) -> Dict[Text, Any]:
-        """Persists this training data to disk and returns necessary
-        information to load it again.
+        """Persists this training data to disk.
+
+        Returns: necessary information to load it again.
         """
         if not os.path.exists(dir_name):
             os.makedirs(dir_name)
@@ -498,9 +499,7 @@ class TrainingData:
     def train_test_split(
         self, train_frac: float = 0.8, random_seed: Optional[int] = None
     ) -> Tuple["TrainingData", "TrainingData"]:
-        """Split into a training and test dataset,
-        preserving the fraction of examples per intent.
-        """
+        """Split into a training and test dataset, preserving the fraction of examples per intent."""  # noqa: E501
         # collect all nlu data
         test, train = self.split_nlu_examples(train_frac, random_seed)
 

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -107,7 +107,8 @@ 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.
@@ -174,10 +175,7 @@ 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
-        and config.get(PROVIDER_CONFIG_KEY) is None
-    ):
+    if config.get(DEPLOYMENT_CONFIG_KEY) is not None:
         return True
 
     return False

rasa/shared/providers/embedding/_base_litellm_embedding_client.py

@@ -5,8 +5,6 @@ import litellm
 import logging
 import structlog
 from litellm import aembedding, embedding, validate_environment
-
-from rasa.shared.constants import API_BASE_CONFIG_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -87,10 +85,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(
-            self._litellm_model_name,
-            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
-        )
+        validation_info = validate_environment(self._litellm_model_name)
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):

rasa/shared/providers/llm/_base_litellm_client.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 from typing import Dict, List, Any, Union
-import logging
 
+import logging
 import structlog
 from litellm import (
     completion,
@@ -9,7 +9,6 @@ from litellm import (
     validate_environment,
 )
 
-from rasa.shared.constants import API_BASE_CONFIG_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -30,7 +29,8 @@ logging.getLogger("LiteLLM").setLevel(logging.WARNING)
 
 
 class _BaseLiteLLMClient:
-    """An abstract base class for LiteLLM clients.
+    """
+    An abstract base class for LiteLLM clients.
 
     This class defines the interface and common functionality for all clients
     based on LiteLLM.
@@ -103,10 +103,7 @@ class _BaseLiteLLMClient:
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(
-            self._litellm_model_name,
-            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
-        )
+        validation_info = validate_environment(self._litellm_model_name)
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):
@@ -135,15 +132,14 @@ class _BaseLiteLLMClient:
 
     @suppress_logs(log_level=logging.WARNING)
     def completion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """Synchronously generate completions for given list of messages.
+        """
+        Synchronously generate completions for given list of messages.
 
         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.
         """
@@ -158,15 +154,14 @@ class _BaseLiteLLMClient:
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """Asynchronously generate completions for given list of messages.
+        """
+        Asynchronously generate completions for given list of messages.
 
         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.
         """
@@ -177,23 +172,7 @@ class _BaseLiteLLMClient:
             )
             return self._format_response(response)
         except Exception as e:
-            message = ""
-            from rasa.shared.providers.llm.self_hosted_llm_client import (
-                SelfHostedLLMClient,
-            )
-
-            if isinstance(self, SelfHostedLLMClient):
-                message = (
-                    "If you are using 'provider=self-hosted' to call a hosted vllm "
-                    "server make sure your config is correctly setup. You should have "
-                    "the following mandatory keys in your config: "
-                    "provider=self-hosted; "
-                    "model='<your-vllm-model-name>'; "
-                    "api_base='your-hosted-vllm-serv'."
-                    "In case you are getting OpenAI connection errors, such as missing "
-                    "API key, your configuration is incorrect."
-                )
-            raise ProviderClientAPIException(e, message)
+            raise ProviderClientAPIException(e)
 
     def _format_messages(self, messages: Union[List[str], str]) -> List[Dict[str, str]]:
         """Formats messages (or a single message) to OpenAI format."""
@@ -237,7 +216,8 @@ class _BaseLiteLLMClient:
 
     @staticmethod
     def _ensure_certificates() -> None:
-        """Configures SSL certificates for LiteLLM. This method is invoked during
+        """
+        Configures SSL certificates for LiteLLM. This method is invoked during
         client initialization.
 
         LiteLLM may utilize `openai` clients or other providers that require

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -4,13 +4,9 @@ from litellm import (
     atext_completion,
 )
 import logging
-import os
 import structlog
 
-from rasa.shared.constants import (
-    SELF_HOSTED_VLLM_PREFIX,
-    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
-)
+from rasa.shared.constants import OPENAI_PROVIDER
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
@@ -61,7 +57,6 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         self._api_version = api_version
         self._use_chat_completions_endpoint = use_chat_completions_endpoint
         self._extra_parameters = kwargs or {}
-        self._apply_dummy_api_key_if_missing()
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "SelfHostedLLMClient":
@@ -162,8 +157,8 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
 
         <openai>/<model or deployment name>
         """
-        if self.model and f"{SELF_HOSTED_VLLM_PREFIX}/" not in self.model:
-            return f"{SELF_HOSTED_VLLM_PREFIX}/{self.model}"
+        if self.model and f"{OPENAI_PROVIDER}/" not in self.model:
+            return f"{OPENAI_PROVIDER}/{self.model}"
         return self.model
 
     @property
@@ -284,10 +279,3 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             formatted_response=formatted_response.to_dict(),
         )
         return formatted_response
-
-    @staticmethod
-    def _apply_dummy_api_key_if_missing() -> None:
-        if not os.getenv(SELF_HOSTED_VLLM_API_KEY_ENV_VAR):
-            os.environ[SELF_HOSTED_VLLM_API_KEY_ENV_VAR] = (
-                "dummy_self_hosted_llm_api_key"
-            )

rasa/shared/utils/common.py

@@ -86,31 +86,11 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     return sorted(dicts, key=lambda d: next(iter(d.keys())))
 
 
-def lazy_property(function: Callable) -> Any:
-    """Allows to avoid recomputing a property over and over.
-
-    The result gets stored in a local var. Computation of the property
-    will happen once, on the first call of the property. All
-    succeeding calls will use the value stored in the private property.
-    """
-    attr_name = "_lazy_" + function.__name__
-
-    def _lazyprop(self: Any) -> Any:
-        if not hasattr(self, attr_name):
-            setattr(self, attr_name, function(self))
-        return getattr(self, attr_name)
-
-    return property(_lazyprop)
-
-
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
-
     Works for `async` and `sync` methods. Don't apply this to functions.
-
     Args:
         f: The decorated method whose return value should be cached.
-
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -176,8 +156,9 @@ def transform_collection_to_sentence(collection: Collection[Text]) -> Text:
 def minimal_kwargs(
     kwargs: Dict[Text, Any], func: Callable, excluded_keys: Optional[List] = None
 ) -> Dict[Text, Any]:
-    """Returns only the kwargs which are required by a function. Keys, contained in
-    the exception list, are not included.
+    """Returns only the kwargs which are required by a function.
+
+    Keys, contained in the exception list, are not included.
 
     Args:
         kwargs: All available kwargs.

rasa/shared/utils/io.py

@@ -13,7 +13,6 @@ from typing import Any, cast, Callable, Dict, List, Optional, Text, Type, TypeVa
 import warnings
 import random
 import string
-
 import portalocker
 
 from rasa.shared.constants import (

rasa/shared/utils/llm.py

@@ -1,4 +1,3 @@
-import sys
 from functools import wraps
 from typing import (
     Any,
@@ -13,7 +12,6 @@ from typing import (
     cast,
 )
 import json
-
 import structlog
 
 import rasa.shared.utils.io
@@ -53,6 +51,7 @@ from rasa.shared.providers.mappings import (
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     get_client_config_class_from_provider,
 )
+from rasa.shared.utils.cli import print_error_and_exit
 
 if TYPE_CHECKING:
     from rasa.shared.core.trackers import DialogueStateTracker
@@ -67,7 +66,7 @@ DEFAULT_OPENAI_GENERATE_MODEL_NAME = "gpt-3.5-turbo"
 
 DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-3.5-turbo"
 
-DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED = "gpt-4-0613"
+DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED = "gpt-4"
 
 DEFAULT_OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-ada-002"
 
@@ -411,40 +410,44 @@ def try_instantiate_llm_client(
     default_llm_config: Optional[Dict],
     log_source_function: str,
     log_source_component: str,
-) -> None:
+) -> LLMClient:
     """Validate llm configuration."""
     try:
-        llm_factory(custom_llm_config, default_llm_config)
+        return llm_factory(custom_llm_config, default_llm_config)
     except (ProviderClientValidationError, ValueError) as e:
         structlogger.error(
             f"{log_source_function}.llm_instantiation_failed",
-            event_info=(
-                f"Unable to create the LLM client for component - "
-                f"{log_source_component}. Please make sure you specified the required "
-                f"environment variables and configuration keys."
-            ),
+            message="Unable to instantiate LLM client.",
             error=e,
         )
-        sys.exit(1)
+        print_error_and_exit(
+            f"Unable to create the LLM client for component - {log_source_component}. "
+            f"Please make sure you specified the required environment variables. "
+            f"Error: {e}"
+        )
 
 
-def try_instantiate_embedder(
-    custom_embeddings_config: Optional[Dict],
-    default_embeddings_config: Optional[Dict],
-    log_source_function: str,
-    log_source_component: str,
-) -> EmbeddingClient:
-    """Validate embeddings configuration."""
+def llm_api_health_check(
+    llm_client: LLMClient, log_source_function: str, log_source_component: str
+) -> None:
+    """Perform a health check on the LLM API."""
+    structlogger.info(
+        f"{log_source_function}.llm_api_call",
+        event_info=(
+            f"Performing a health check on the LLM API for the component - "
+            f"{log_source_component}."
+        ),
+        config=llm_client.config,
+    )
     try:
-        return embedder_factory(custom_embeddings_config, default_embeddings_config)
-    except (ProviderClientValidationError, ValueError) as e:
+        llm_client.completion("hello")
+    except Exception as e:
         structlogger.error(
-            f"{log_source_function}.embedder_instantiation_failed",
-            event_info=(
-                f"Unable to create the Embedding client for component - "
-                f"{log_source_component}. Please make sure you specified the required "
-                f"environment variables and configuration keys."
-            ),
+            f"{log_source_function}.llm_api_call_failed",
+            event_info="call to the LLM API failed.",
             error=e,
         )
-        sys.exit(1)
+        print_error_and_exit(
+            f"Call to the LLM API failed for component - {log_source_component}. "
+            f"Error: {e}"
+        )

rasa/shared/utils/schemas/events.py

@@ -127,6 +127,7 @@ ACTION_REVERTED = {"properties": {"event": {"const": "undo"}}}
 USER_UTTERANCE_REVERTED = {"properties": {"event": {"const": "rewind"}}}
 BOT_UTTERED = {"properties": {"event": {"const": "bot"}}}
 SESSION_STARTED = {"properties": {"event": {"const": "session_started"}}}
+SESSION_ENDED = {"properties": {"event": {"const": "session_ended"}}}
 AGENT_UTTERED = {"properties": {"event": {"const": "agent"}}}
 FLOW_STARTED = {
     "properties": {"event": {"const": "flow_started"}, "flow_id": {"type": "string"}}
@@ -206,6 +207,7 @@ EVENT_SCHEMA = {
         FLOW_CANCELLED,
         DIALOGUE_STACK_UPDATED,
         ROUTING_SESSION_ENDED,
+        SESSION_ENDED,
     ],
 }
 

rasa/shared/utils/schemas/model_config.yml

@@ -34,13 +34,3 @@ mapping:
           name:
             type: str
             required: True
-  spaces:
-    type: "seq"
-    required: False
-    sequence:
-      - type: "map"
-        allowempty: True
-        mapping:
-          name:
-            type: str
-            required: True