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

rasa/core/featurizers/tracker_featurizers.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
-
-import logging
-from abc import abstractmethod
-from collections import defaultdict
 from pathlib import Path
+from collections import defaultdict
+from abc import abstractmethod
+import jsonpickle
+import logging
+
+from tqdm import tqdm
 from typing import (
     Tuple,
     List,
@@ -16,30 +18,25 @@ from typing import (
     Set,
     DefaultDict,
     cast,
-    Type,
-    Callable,
-    ClassVar,
 )
-
 import numpy as np
-from tqdm import tqdm
 
+from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
+from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
 import rasa.shared.core.trackers
 import rasa.shared.utils.io
-from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
-from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
-from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.domain import State, Domain
+from rasa.shared.core.events import Event, ActionExecuted, UserUttered
 from rasa.shared.core.constants import (
     USER,
     ACTION_UNLIKELY_INTENT_NAME,
     PREVIOUS_ACTION,
 )
-from rasa.shared.core.domain import State, Domain
-from rasa.shared.core.events import Event, ActionExecuted, UserUttered
-from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
-from rasa.shared.nlu.training_data.features import Features
 from rasa.utils.tensorflow.constants import LABEL_PAD_ID
 from rasa.utils.tensorflow.model_data import ragged_array_to_ndarray
 
@@ -67,10 +64,6 @@ class InvalidStory(RasaException):
 class TrackerFeaturizer:
     """Base class for actual tracker featurizers."""
 
-    # Class registry to store all subclasses
-    _registry: ClassVar[Dict[str, Type["TrackerFeaturizer"]]] = {}
-    _featurizer_type: str = "TrackerFeaturizer"
-
     def __init__(
         self, state_featurizer: Optional[SingleStateFeaturizer] = None
     ) -> None:
@@ -81,36 +74,6 @@ class TrackerFeaturizer:
         """
         self.state_featurizer = state_featurizer
 
-    @classmethod
-    def register(cls, featurizer_type: str) -> Callable:
-        """Decorator to register featurizer subclasses."""
-
-        def wrapper(subclass: Type["TrackerFeaturizer"]) -> Type["TrackerFeaturizer"]:
-            cls._registry[featurizer_type] = subclass
-            # Store the type identifier in the class for serialization
-            subclass._featurizer_type = featurizer_type
-            return subclass
-
-        return wrapper
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Create featurizer instance from dictionary."""
-        featurizer_type = data.pop("type")
-
-        if featurizer_type not in cls._registry:
-            raise ValueError(f"Unknown featurizer type: {featurizer_type}")
-
-        # Get the correct subclass and instantiate it
-        subclass = cls._registry[featurizer_type]
-        return subclass.create_from_dict(data)
-
-    @classmethod
-    @abstractmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Each subclass must implement its own creation from dict method."""
-        pass
-
     @staticmethod
     def _create_states(
         tracker: DialogueStateTracker,
@@ -502,7 +465,9 @@ class TrackerFeaturizer:
             self.state_featurizer.entity_tag_specs = []
 
         # noinspection PyTypeChecker
-        rasa.shared.utils.io.dump_obj_as_json_to_file(featurizer_file, self.to_dict())
+        rasa.shared.utils.io.write_text_file(
+            str(jsonpickle.encode(self)), featurizer_file
+        )
 
     @staticmethod
     def load(path: Union[Text, Path]) -> Optional[TrackerFeaturizer]:
@@ -516,17 +481,7 @@ class TrackerFeaturizer:
         """
         featurizer_file = Path(path) / FEATURIZER_FILE
         if featurizer_file.is_file():
-            data = rasa.shared.utils.io.read_json_file(featurizer_file)
-
-            if "type" not in data:
-                logger.error(
-                    f"Couldn't load featurizer for policy. "
-                    f"File '{featurizer_file}' does not contain all "
-                    f"necessary information. 'type' is missing."
-                )
-                return None
-
-            return TrackerFeaturizer.from_dict(data)
+            return jsonpickle.decode(rasa.shared.utils.io.read_file(featurizer_file))
 
         logger.error(
             f"Couldn't load featurizer for policy. "
@@ -553,16 +508,7 @@ class TrackerFeaturizer:
             )
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "type": self.__class__._featurizer_type,
-            "state_featurizer": (
-                self.state_featurizer.to_dict() if self.state_featurizer else None
-            ),
-        }
-
 
-@TrackerFeaturizer.register("FullDialogueTrackerFeaturizer")
 class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
     """Creates full dialogue training data for time distributed architectures.
 
@@ -700,20 +646,7 @@ class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
 
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "FullDialogueTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(
-            state_featurizer,
-        )
-
-
-@TrackerFeaturizer.register("MaxHistoryTrackerFeaturizer")
 class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -951,25 +884,7 @@ class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        data = super().to_dict()
-        data.update(
-            {
-                "remove_duplicates": self.remove_duplicates,
-                "max_history": self.max_history,
-            }
-        )
-        return data
-
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "MaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
 
-
-@TrackerFeaturizer.register("IntentMaxHistoryTrackerFeaturizer")
 class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -1244,18 +1159,6 @@ class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
-
-    @classmethod
-    def create_from_dict(
-        cls, data: Dict[str, Any]
-    ) -> "IntentMaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
-
 
 def _is_prev_action_unlikely_intent_in_state(state: State) -> bool:
     prev_action_name = state.get(PREVIOUS_ACTION, {}).get(ACTION_NAME)

rasa/core/nlg/contextual_response_rephraser.py

@@ -1,11 +1,13 @@
 from typing import Any, Dict, Optional, Text
 
+import os
 import structlog
 from jinja2 import Template
 
 from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
 from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -23,6 +25,7 @@ from rasa.shared.utils.llm import (
     USER,
     combine_custom_and_default_config,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
     try_instantiate_llm_client,
 )
@@ -97,12 +100,18 @@ class ContextualResponseRephraser(TemplatedNaturalLanguageGenerator):
         self.trace_prompt_tokens = self.nlg_endpoint.kwargs.get(
             "trace_prompt_tokens", False
         )
-        try_instantiate_llm_client(
+        llm_client = try_instantiate_llm_client(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "contextual_response_rephraser.init",
-            "ContextualResponseRephraser",
+            ContextualResponseRephraser.__name__,
         )
+        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
+            llm_api_health_check(
+                llm_client,
+                "contextual_response_rephraser.init",
+                ContextualResponseRephraser.__name__,
+            )
 
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
         """Returns the latest message from the tracker.

rasa/{nlu → core}/persistor.py

@@ -82,14 +82,16 @@ def get_persistor(storage: StorageType) -> Optional[Persistor]:
     Currently, `aws`, `gcs`, `azure` and providing module paths are supported remote
     storages.
     """
-    if storage == RemoteStorageType.AWS:
+    storage = storage.value if isinstance(storage, RemoteStorageType) else storage
+
+    if storage == RemoteStorageType.AWS.value:
         return AWSPersistor(
             os.environ.get(BUCKET_NAME_ENV), os.environ.get(AWS_ENDPOINT_URL_ENV)
         )
-    if storage == RemoteStorageType.GCS:
+    if storage == RemoteStorageType.GCS.value:
         return GCSPersistor(os.environ.get(BUCKET_NAME_ENV))
 
-    if storage == RemoteStorageType.AZURE:
+    if storage == RemoteStorageType.AZURE.value:
         return AzurePersistor(
             os.environ.get(AZURE_CONTAINER_ENV),
             os.environ.get(AZURE_ACCOUNT_NAME_ENV),
@@ -123,36 +125,24 @@ class Persistor(abc.ABC):
         """Downloads a model that has been persisted to cloud storage.
 
         Downloaded model will be saved to the `target_path`.
-        If `target_path` is a directory, the model will be downloaded to that directory.
-        If `target_path` is a file, the model will be downloaded to that file.
+        If `target_path` is a directory, the model will be saved to that directory.
+        If `target_path` is a file, the model will be saved to that file.
 
         Args:
             model_name: The name of the model to retrieve.
-            target_path: The path to which the model should be downloaded.
+            target_path: The path to which the model should be saved.
         """
         tar_name = model_name
         if not model_name.endswith(MODEL_ARCHIVE_EXTENSION):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
-        remote_object_path = self._create_file_key(tar_name)
-        self._retrieve_tar(remote_object_path)
+        tar_name = self._create_file_key(tar_name)
+        self._retrieve_tar(tar_name)
+        self._copy(os.path.basename(tar_name), target_path)
 
-        target_tar_file_name = os.path.basename(tar_name)
         if os.path.isdir(target_path):
-            target_path = os.path.join(target_path, target_tar_file_name)
-
-        if not os.path.exists(target_path):
-            structlogger.debug(
-                "persistor.retrieve.copy_model",
-                event_info=f"Copying model '{target_tar_file_name}' to "
-                f"'{target_path}'.",
-            )
-            self._copy(target_tar_file_name, target_path)
+            return os.path.join(target_path, model_name)
 
-        structlogger.debug(
-            "persistor.retrieve.model_retrieved",
-            event_info=f"Model retrieved and saved to '{target_path}'.",
-        )
         return target_path
 
     @abc.abstractmethod
@@ -175,7 +165,7 @@ class Persistor(abc.ABC):
             os.path.join(dirpath, base_name),
             "gztar",
             root_dir=model_directory,
-            base_dir=".",
+            base_dir="../nlu",
         )
         file_key = os.path.basename(tar_name)
         return file_key, tar_name
@@ -272,11 +262,6 @@ class AWSPersistor(Persistor):
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
-        structlogger.debug(
-            "aws_persistor.persist_tar.uploading_model",
-            event_info=f"Uploading tar archive {file_key} to "
-            f"s3 bucket '{self.bucket_name}'.",
-        )
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
@@ -344,7 +329,7 @@ class GCSPersistor(Persistor):
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         blob = self.bucket.blob(target_filename)
-        blob.download_to_filename(os.path.basename(target_filename))
+        blob.download_to_filename(target_filename)
 
 
 class AzurePersistor(Persistor):
@@ -385,19 +370,12 @@ class AzurePersistor(Persistor):
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to Azure."""
         with open(tar_path, "rb") as data:
-            self._container_client().upload_blob(
-                name=file_key,
-                data=data,
-                # overwrite is set to True to keep in line with
-                # how GCS and AWS APIs work this enables easy
-                # updating of models in the cloud
-                overwrite=True,
-            )
+            self._container_client().upload_blob(name=file_key, data=data)
 
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to Azure."""
         blob_client = self._container_client().get_blob_client(target_filename)
 
-        with open(os.path.basename(target_filename), "wb") as blob:
+        with open(target_filename, "wb") as blob:
             download_stream = blob_client.download_blob()
             blob.write(download_stream.readall())

rasa/core/policies/enterprise_search_policy.py

@@ -1,5 +1,6 @@
 import importlib.resources
 import json
+import os
 import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
 
@@ -47,6 +48,7 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -72,11 +74,11 @@ from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
     embedder_factory,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
     try_instantiate_llm_client,
-    try_instantiate_embedder,
 )
 from rasa.core.information_retrieval.faiss import FAISS_Store
 from rasa.core.information_retrieval import (
@@ -293,12 +295,18 @@ class EnterpriseSearchPolicy(Policy):
             )
 
         # validate llm configuration
-        try_instantiate_llm_client(
+        llm_client = try_instantiate_llm_client(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "enterprise_search_policy.train",
-            "EnterpriseSearchPolicy",
+            EnterpriseSearchPolicy.__name__,
         )
+        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
+            llm_api_health_check(
+                llm_client,
+                "enterprise_search_policy.train",
+                EnterpriseSearchPolicy.__name__,
+            )
 
         if store_type == DEFAULT_VECTOR_STORE_TYPE:
             logger.info("enterprise_search_policy.train.faiss")
@@ -662,18 +670,6 @@ class EnterpriseSearchPolicy(Policy):
         execution_context: ExecutionContext,
         **kwargs: Any,
     ) -> "EnterpriseSearchPolicy":
-        try_instantiate_llm_client(
-            config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "enterprise_search_policy.load",
-            EnterpriseSearchPolicy.__name__,
-        )
-        try_instantiate_embedder(
-            config.get(EMBEDDINGS_CONFIG_KEY),
-            DEFAULT_EMBEDDINGS_CONFIG,
-            "enterprise_search_policy.load",
-            EnterpriseSearchPolicy.__name__,
-        )
         """Loads a trained policy (see parent class for full docstring)."""
         prompt_template = None
         store_type = config.get(VECTOR_STORE_PROPERTY, {}).get(
@@ -708,6 +704,7 @@ class EnterpriseSearchPolicy(Policy):
             logger.warning(
                 "enterprise_search_policy.load.failed", error=e, resource=resource.name
             )
+
         return cls(
             config,
             model_storage,

rasa/core/policies/flows/flow_executor.py

@@ -484,8 +484,7 @@ def validate_collect_step(
     step: CollectInformationFlowStep,
     stack: DialogueStack,
     available_actions: List[str],
-    slots: Dict[str, Slot],
-    flow_name: str,
+    slots: Dict[Text, Slot],
 ) -> bool:
     """Validate that a collect step can be executed.
 
@@ -508,12 +507,12 @@ def validate_collect_step(
         slot_name=step.collect,
     )
 
-    cancel_flow_and_push_internal_error(stack, flow_name)
+    cancel_flow_and_push_internal_error(stack)
 
     return False
 
 
-def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) -> None:
+def cancel_flow_and_push_internal_error(stack: DialogueStack) -> None:
     """Cancel the top user flow and push the internal error pattern."""
     top_frame = stack.top()
 
@@ -525,7 +524,7 @@ def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) ->
         canceled_frames = CancelFlowCommand.select_canceled_frames(stack)
         stack.push(
             CancelPatternFlowStackFrame(
-                canceled_name=flow_name,
+                canceled_name=top_frame.flow_id,
                 canceled_frames=canceled_frames,
             )
         )
@@ -537,7 +536,6 @@ def validate_custom_slot_mappings(
     stack: DialogueStack,
     tracker: DialogueStateTracker,
     available_actions: List[str],
-    flow_name: str,
 ) -> bool:
     """Validate a slot with custom mappings.
 
@@ -558,7 +556,7 @@ def validate_custom_slot_mappings(
                     action=step.collect_action,
                     collect=step.collect,
                 )
-                cancel_flow_and_push_internal_error(stack, flow_name)
+                cancel_flow_and_push_internal_error(stack)
                 return False
 
     return True
@@ -598,12 +596,7 @@ def run_step(
 
     if isinstance(step, CollectInformationFlowStep):
         return _run_collect_information_step(
-            available_actions,
-            initial_events,
-            stack,
-            step,
-            tracker,
-            flow.readable_name(),
+            available_actions, initial_events, stack, step, tracker
         )
 
     elif isinstance(step, ActionFlowStep):
@@ -723,18 +716,15 @@ def _run_collect_information_step(
     stack: DialogueStack,
     step: CollectInformationFlowStep,
     tracker: DialogueStateTracker,
-    flow_name: str,
 ) -> FlowStepResult:
-    is_step_valid = validate_collect_step(
-        step, stack, available_actions, tracker.slots, flow_name
-    )
+    is_step_valid = validate_collect_step(step, stack, available_actions, tracker.slots)
 
     if not is_step_valid:
         # if we return any other FlowStepResult, the assistant will stay silent
         # instead of triggering the internal error pattern
         return ContinueFlowWithNextStep(events=initial_events)
     is_mapping_valid = validate_custom_slot_mappings(
-        step, stack, tracker, available_actions, flow_name
+        step, stack, tracker, available_actions
     )
 
     if not is_mapping_valid:

rasa/core/policies/intentless_policy.py

@@ -1,5 +1,6 @@
 import importlib.resources
 import math
+import os
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING, Text, Tuple
 
@@ -31,6 +32,7 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     REQUIRED_SLOTS_KEY,
     EMBEDDINGS_CONFIG_KEY,
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -67,11 +69,11 @@ from rasa.shared.utils.llm import (
     combine_custom_and_default_config,
     embedder_factory,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
     try_instantiate_llm_client,
-    try_instantiate_embedder,
 )
 from rasa.utils.ml_utils import (
     extract_ai_response_examples,
@@ -488,12 +490,16 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
-        try_instantiate_llm_client(
+        llm_client = try_instantiate_llm_client(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "intentless_policy.train",
-            "IntentlessPolicy",
+            IntentlessPolicy.__name__,
         )
+        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
+            llm_api_health_check(
+                llm_client, "intentless_policy.train", IntentlessPolicy.__name__
+            )
 
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()
@@ -919,18 +925,6 @@ class IntentlessPolicy(Policy):
         **kwargs: Any,
     ) -> "IntentlessPolicy":
         """Loads a trained policy (see parent class for full docstring)."""
-        try_instantiate_llm_client(
-            config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "intentless_policy.load",
-            IntentlessPolicy.__name__,
-        )
-        try_instantiate_embedder(
-            config.get(EMBEDDINGS_CONFIG_KEY),
-            DEFAULT_EMBEDDINGS_CONFIG,
-            "intentless_policy.load",
-            IntentlessPolicy.__name__,
-        )
         responses_docsearch = None
         samples_docsearch = None
         prompt_template = None
@@ -956,6 +950,7 @@ class IntentlessPolicy(Policy):
             structlogger.warning(
                 "intentless_policy.load.failed", error=e, resource_name=resource.name
             )
+
         return cls(
             config,
             model_storage,