rasa-pro 3.13.0.dev5__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/core/exporter.py

@@ -10,7 +10,7 @@ import rasa.shared.utils.io
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.brokers.pika import PikaEventBroker
 from rasa.core.constants import RASA_EXPORT_PROCESS_ID_HEADER_NAME
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.exceptions import (
     NoConversationsInTrackerStoreError,
     NoEventsToMigrateError,

rasa/core/http_interpreter.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 from typing import Any, Dict, Optional, Text
 
@@ -49,7 +48,6 @@ class RasaNLUHttpInterpreter:
         if not self.endpoint_config or self.endpoint_config.url is None:
             structlogger.error(
                 "http.parse.text",
-                text=copy.deepcopy(text),
                 event_info="No rasa NLU server specified!",
             )
             return None
@@ -71,18 +69,16 @@ class RasaNLUHttpInterpreter:
                 if resp.status == 200:
                     return await resp.json()
                 else:
-                    response_text = await resp.text()
                     structlogger.error(
                         "http.parse.text.failure",
-                        text=copy.deepcopy(text),
-                        response_text=copy.deepcopy(response_text),
+                        event_info="Failed to parse text",
                     )
                     return None
-        except Exception:  # skipcq: PYL-W0703
+        except Exception as e:  # skipcq: PYL-W0703
             # need to catch all possible exceptions when doing http requests
             # (timeouts, value errors, parser errors, ...)
             structlogger.exception(
                 "http.parse.text.exception",
-                text=copy.deepcopy(text),
+                event_info=f"Exception occurred while parsing text. Error: {e}",
             )
             return None

rasa/core/jobs.py

@@ -1,12 +1,13 @@
 import asyncio
 import logging
+from typing import Optional
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from pytz import UnknownTimeZoneError, utc
 
 import rasa.shared.utils.io
 
-__scheduler = None
+__scheduler: Optional[AsyncIOScheduler] = None
 
 logger = logging.getLogger(__name__)
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -5,15 +5,20 @@ 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.core.nlg.summarize import (
+    _count_multiple_utterances_as_single_turn,
+    summarize_conversation,
+)
 from rasa.shared.constants import (
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
@@ -53,12 +58,13 @@ RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
 DEFAULT_REPHRASE_ALL = False
 DEFAULT_SUMMARIZE_HISTORY = True
 DEFAULT_MAX_HISTORICAL_TURNS = 5
+DEFAULT_COUNT_MULTIPLE_UTTERANCES_AS_SINGLE_TURN = True
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_GENERATE_MODEL_NAME,
-    "temperature": 0.3,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.3,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 
@@ -70,6 +76,7 @@ its meaning. Use simple {{language}}.
 Context / previous conversation with the user:
 {{history}}
 
+Last user message:
 {{current_input}}
 
 Suggested AI Response: {{suggested_response}}
@@ -122,6 +129,11 @@ class ContextualResponseRephraser(
             "max_historical_turns", DEFAULT_MAX_HISTORICAL_TURNS
         )
 
+        self.count_multiple_utterances_as_single_turn = self.nlg_endpoint.kwargs.get(
+            "count_multiple_utterances_as_single_turn",
+            DEFAULT_COUNT_MULTIPLE_UTTERANCES_AS_SINGLE_TURN,
+        )
+
         self.llm_config = resolve_model_client_config(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
             ContextualResponseRephraser.__name__,
@@ -258,8 +270,16 @@ class ContextualResponseRephraser(
         Returns:
         The history for the prompt.
         """
+        # Count multiple utterances by bot/user as single turn in conversation history
+        turns_wrapper = (
+            _count_multiple_utterances_as_single_turn
+            if self.count_multiple_utterances_as_single_turn
+            else None
+        )
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
-        return await summarize_conversation(tracker, llm, max_turns=5)
+        return await summarize_conversation(
+            tracker, llm, max_turns=5, turns_wrapper=turns_wrapper
+        )
 
     async def rephrase(
         self,
@@ -281,19 +301,26 @@ class ContextualResponseRephraser(
 
         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 ""
+        # Last user message (=current input) should always be in prompt if available
+        last_message_by_user = getattr(tracker.latest_message, "text", "")
+        current_input = (
+            f"{USER}: {last_message_by_user}" if last_message_by_user 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
+            # Count multiple utterances by bot/user as single turn
+            turns_wrapper = (
+                _count_multiple_utterances_as_single_turn
+                if self.count_multiple_utterances_as_single_turn
+                else None
+            )
             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 = ""
+            history = tracker_as_readable_transcript(
+                tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+            )
 
         prompt = Template(prompt_template_text).render(
             history=history,

rasa/core/nlg/generator.py

@@ -292,7 +292,6 @@ def _evaluate_predicate(constraint: str, filled_slots: Dict[Text, Any]) -> bool:
         structlogger.error(
             "rasa.core.nlg.generator.evaluate_conditional_response_predicate.error",
             predicate=constraint,
-            document=document,
             error=str(e),
         )
         return False

rasa/core/nlg/interpolator.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 import re
 from typing import Any, Dict, List, Text, Union
@@ -70,9 +69,9 @@ def interpolate_format_template(response: Text, values: Dict[Text, Text]) -> Tex
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 
@@ -98,9 +97,9 @@ def interpolate_jinja_template(response: Text, values: Dict[Text, Any]) -> Text:
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 

rasa/core/nlg/summarize.py

@@ -1,9 +1,10 @@
-from typing import Optional
+from itertools import groupby
+from typing import Callable, List, Optional
 
 import structlog
 from jinja2 import Template
 
-from rasa.core.tracker_store import DialogueStateTracker
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
@@ -23,20 +24,49 @@ SUMMARY_PROMPT_TEMPLATE = Template(_DEFAULT_SUMMARIZER_TEMPLATE)
 MAX_TURNS_DEFAULT = 20
 
 
+def _count_multiple_utterances_as_single_turn(transcript: List[str]) -> List[str]:
+    """Counts multiple utterances as a single turn.
+
+    Args:
+        transcript: the lines of the transcript
+
+    Returns:
+        transcript: with multiple utterances counted as a single turn
+    """
+    if not transcript:
+        return []
+
+    def get_speaker_label(line: str) -> str:
+        return line.partition(": ")[0] if ": " in line else ""
+
+    modified_transcript = [
+        f"{speaker}: {' '.join(line.partition(': ')[2] for line in group)}"
+        for speaker, group in groupby(transcript, key=get_speaker_label)
+        if speaker
+    ]
+
+    return modified_transcript
+
+
 def _create_summarization_prompt(
-    tracker: DialogueStateTracker, max_turns: Optional[int]
+    tracker: DialogueStateTracker,
+    max_turns: Optional[int],
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]],
 ) -> str:
     """Creates an LLM prompt to summarize the conversation in the tracker.
 
     Args:
         tracker: tracker of the conversation to be summarized
         max_turns: maximum number of turns to summarize
+        turns_wrapper: optional function to wrap the turns
 
 
     Returns:
         The prompt to summarize the conversation.
     """
-    transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+    transcript = tracker_as_readable_transcript(
+        tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+    )
     return SUMMARY_PROMPT_TEMPLATE.render(
         conversation=transcript,
     )
@@ -46,6 +76,7 @@ async def summarize_conversation(
     tracker: DialogueStateTracker,
     llm: LLMClient,
     max_turns: Optional[int] = MAX_TURNS_DEFAULT,
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
 ) -> str:
     """Summarizes the dialogue using the LLM.
 
@@ -53,11 +84,12 @@ async def summarize_conversation(
         tracker: the tracker to summarize
         llm: the LLM to use for summarization
         max_turns: maximum number of turns to summarize
+        turns_wrapper: optional function to wrap the turns
 
     Returns:
         The summary of the dialogue.
     """
-    prompt = _create_summarization_prompt(tracker, max_turns)
+    prompt = _create_summarization_prompt(tracker, max_turns, turns_wrapper)
     try:
         llm_response = await llm.acompletion(prompt)
         summarization = llm_response.choices[0].strip()
@@ -66,6 +98,8 @@ async def summarize_conversation(
         )
         return summarization
     except Exception as e:
-        transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+        transcript = tracker_as_readable_transcript(
+            tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+        )
         structlogger.error("summarization.error", error=e)
         return transcript

rasa/core/persistor.py

@@ -121,10 +121,12 @@ def get_persistor(storage: StorageType) -> Optional[Persistor]:
 class Persistor(abc.ABC):
     """Store models in cloud and fetch them when needed."""
 
-    def persist(self, trained_model: str) -> None:
+    def persist(self, trained_model: str, remote_root_only: bool = False) -> None:
         """Uploads a trained model persisted in the `target_dir` to cloud storage."""
         absolute_file_key = self._create_file_key(trained_model)
-        file_key = Path(absolute_file_key).name
+        file_key = (
+            Path(absolute_file_key).name if remote_root_only else absolute_file_key
+        )
         self._persist_tar(file_key, trained_model)
 
     def retrieve(self, model_name: Text, target_path: Text) -> Text:
@@ -143,30 +145,32 @@ class Persistor(abc.ABC):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
         tar_name = self._create_file_key(tar_name)
-        target_filename = os.path.basename(tar_name)
-        self._retrieve_tar(target_filename)
-        self._copy(os.path.basename(tar_name), target_path)
+        self._retrieve_tar(tar_name, target_path)
 
         if os.path.isdir(target_path):
             return os.path.join(target_path, model_name)
 
         return target_path
 
-    def size_of_persisted_model(self, model_name: Text) -> int:
+    def size_of_persisted_model(
+        self, model_name: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to cloud storage.
 
         Args:
             model_name: The name of the model to retrieve.
+            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)
         tar_name = self._create_file_key(tar_name)
-        target_filename = os.path.basename(tar_name)
-        return self._retrieve_tar_size(target_filename)
+        return self._retrieve_tar_size(tar_name, target_path)
 
-    def _retrieve_tar_size(self, filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to cloud storage."""
         structlogger.warning(
             "persistor.retrieve_tar_size.not_implemented",
@@ -179,11 +183,11 @@ class Persistor(abc.ABC):
                 "size directly from the cloud storage."
             ),
         )
-        self._retrieve_tar(filename)
+        self._retrieve_tar(filename, target_path)
         return os.path.getsize(os.path.basename(filename))
 
     @abc.abstractmethod
-    def _retrieve_tar(self, filename: Text) -> None:
+    def _retrieve_tar(self, filename: str, target_path: Optional[str] = None) -> None:
         """Downloads a model previously persisted to cloud storage."""
         raise NotImplementedError
 
@@ -302,7 +306,9 @@ class AWSPersistor(Persistor):
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
-    def _retrieve_tar_size(self, model_path: Text) -> int:
+    def _retrieve_tar_size(
+        self, model_path: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to s3."""
         try:
             obj = self.s3.Object(self.bucket_name, model_path)
@@ -310,7 +316,9 @@ class AWSPersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: str) -> None:
+    def _retrieve_tar(
+        self, target_filename: str, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to s3."""
         from botocore import exceptions
 
@@ -320,8 +328,14 @@ class AWSPersistor(Persistor):
             f"in the bucket."
         )
 
+        tar_name = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else os.path.basename(target_filename)
+        )
+
         try:
-            with open(target_filename, "wb") as f:
+            with open(tar_name, "wb") as f:
                 self.bucket.download_fileobj(target_filename, f)
 
             structlogger.debug(
@@ -425,7 +439,9 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(file_key)
         blob.upload_from_filename(tar_path)
 
-    def _retrieve_tar_size(self, target_filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to GCS."""
         try:
             blob = self.bucket.blob(target_filename)
@@ -433,13 +449,22 @@ class GCSPersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
+    def _retrieve_tar(
+        self, target_filename: str, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         from google.api_core import exceptions
 
         blob = self.bucket.blob(target_filename)
+
+        destination = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else target_filename
+        )
+
         try:
-            blob.download_to_filename(target_filename)
+            blob.download_to_filename(destination)
 
             structlogger.debug(
                 "gcs_persistor.retrieve_tar.object_found", object_key=target_filename
@@ -500,7 +525,9 @@ class AzurePersistor(Persistor):
         with open(tar_path, "rb") as data:
             self._container_client().upload_blob(name=file_key, data=data)
 
-    def _retrieve_tar_size(self, target_filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to Azure."""
         try:
             blob_client = self._container_client().get_blob_client(target_filename)
@@ -509,12 +536,20 @@ class AzurePersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
+    def _retrieve_tar(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to Azure."""
         from azure.core.exceptions import AzureError
 
+        destination = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else target_filename
+        )
+
         try:
-            with open(target_filename, "wb") as model_file:
+            with open(destination, "wb") as model_file:
                 blob_client = self._container_client().get_blob_client(target_filename)
                 download_stream = blob_client.download_blob()
                 model_file.write(download_stream.readall())