rasa-pro 3.11.0__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/information_retrieval/qdrant.py

@@ -62,7 +62,6 @@ class Qdrant_Store(InformationRetrieval):
             embeddings=self.embeddings,
             content_payload_key=params.get("content_payload_key", "text"),
             metadata_payload_key=params.get("metadata_payload_key", "metadata"),
-            vector_name=params.get("vector_name", None),
         )
 
     async def search(

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.core.nlg.summarize import summarize_conversation
 from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -13,25 +15,24 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import BotUttered, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_GENERATE_MODEL_NAME,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     USER,
     combine_custom_and_default_config,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
-    resolve_model_client_config,
-)
-from rasa.shared.utils.llm import (
-    tracker_as_readable_transcript,
+    try_instantiate_llm_client,
 )
 from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.nlg.summarize import summarize_conversation
+
 from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
@@ -40,11 +41,7 @@ RESPONSE_REPHRASING_KEY = "rephrase"
 
 RESPONSE_REPHRASING_TEMPLATE_KEY = "rephrase_prompt"
 
-RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
-
 DEFAULT_REPHRASE_ALL = False
-DEFAULT_SUMMARIZE_HISTORY = True
-DEFAULT_MAX_HISTORICAL_TURNS = 5
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
@@ -69,9 +66,7 @@ Suggested AI Response: {{suggested_response}}
 Rephrased AI Response:"""
 
 
-class ContextualResponseRephraser(
-    LLMHealthCheckMixin, TemplatedNaturalLanguageGenerator
-):
+class ContextualResponseRephraser(TemplatedNaturalLanguageGenerator):
     """Generates responses based on modified templates.
 
     The templates are filled with the entities and slots that are available in the
@@ -105,24 +100,18 @@ class ContextualResponseRephraser(
         self.trace_prompt_tokens = self.nlg_endpoint.kwargs.get(
             "trace_prompt_tokens", False
         )
-        self.summarize_history = self.nlg_endpoint.kwargs.get(
-            "summarize_history", DEFAULT_SUMMARIZE_HISTORY
-        )
-        self.max_historical_turns = self.nlg_endpoint.kwargs.get(
-            "max_historical_turns", DEFAULT_MAX_HISTORICAL_TURNS
-        )
-
-        self.llm_config = resolve_model_client_config(
+        llm_client = try_instantiate_llm_client(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
-            ContextualResponseRephraser.__name__,
-        )
-
-        self.perform_llm_health_check(
-            self.llm_config,
             DEFAULT_LLM_CONFIG,
             "contextual_response_rephraser.init",
             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.
@@ -151,7 +140,9 @@ class ContextualResponseRephraser(
         Returns:
             generated text
         """
-        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        llm = llm_factory(
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
+        )
 
         try:
             llm_response = await llm.acompletion(prompt)
@@ -165,7 +156,7 @@ class ContextualResponseRephraser(
     def llm_property(self, prop: str) -> Optional[str]:
         """Returns a property of the LLM provider."""
         return combine_custom_and_default_config(
-            self.llm_config, DEFAULT_LLM_CONFIG
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
         ).get(prop)
 
     def custom_prompt_template(self, prompt_template: str) -> Optional[str]:
@@ -198,7 +189,9 @@ class ContextualResponseRephraser(
         Returns:
         The history for the prompt.
         """
-        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        llm = llm_factory(
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
+        )
         return await summarize_conversation(tracker, llm, max_turns=5)
 
     async def rephrase(
@@ -219,24 +212,13 @@ class ContextualResponseRephraser(
         if not (response_text := response.get(KEY_RESPONSES_TEXT)):
             return response
 
-        prompt_template_text = self._template_for_response_rephrasing(response)
-
-        # Retrieve inputs for the dynamic prompt
         latest_message = self._last_message_if_human(tracker)
         current_input = f"{USER}: {latest_message}" if latest_message else ""
 
-        # Only summarise conversation history if flagged
-        if self.summarize_history:
-            history = await self._create_history(tracker)
-        else:
-            # make sure the transcript/history contains the last user utterance
-            max_turns = max(self.max_historical_turns, 1)
-            history = tracker_as_readable_transcript(tracker, max_turns=max_turns)
-            # the history already contains the current input
-            current_input = ""
+        prompt_template_text = self._template_for_response_rephrasing(response)
 
         prompt = Template(prompt_template_text).render(
-            history=history,
+            history=await self._create_history(tracker),
             suggested_response=response_text,
             current_input=current_input,
             slots=tracker.current_slot_values(),
@@ -253,7 +235,6 @@ class ContextualResponseRephraser(
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
         if not (updated_text := await self._generate_llm_response(prompt)):
             # If the LLM fails to generate a response, we