rasa-pro 3.11.0a2__py3-none-any.whl → 3.11.0a4.dev1__py3-none-any.whl

rasa/core/utils.py

@@ -1,8 +1,9 @@
+import structlog
 import logging
 import os
 from pathlib import Path
 from socket import SOCK_DGRAM, SOCK_STREAM
-from typing import Any, Dict, Optional, Set, TYPE_CHECKING, Text, Tuple, Union
+from typing import Any, Dict, Optional, List, Set, TYPE_CHECKING, Text, Tuple, Union
 
 import numpy as np
 from sanic import Sanic
@@ -19,14 +20,18 @@ from rasa.core.constants import (
 from rasa.core.lock_store import LockStore, RedisLockStore, InMemoryLockStore
 from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
+from rasa.utils.endpoints import (
+    EndpointConfig,
+    read_endpoint_config,
+    read_property_config_from_endpoints_file,
+)
 from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 def configure_file_logging(
@@ -124,15 +129,17 @@ def list_routes(app: Sanic) -> Dict[Text, Text]:
         for arg in route._params:
             options[arg] = f"[{arg}]"
 
-        handlers = [(next(iter(route.methods)), route.name.replace("rasa_server.", ""))]
+        name = route.name.replace("rasa_server.", "")
+        methods = ",".join(route.methods)
 
-        for method, name in handlers:
-            full_endpoint = "/" + "/".join(endpoint)
-            line = unquote(f"{full_endpoint:50s} {method:30s} {name}")
-            output[name] = line
+        full_endpoint = "/" + "/".join(endpoint)
+        line = unquote(f"{full_endpoint:50s} {methods:30s} {name}")
+        output[name] = line
 
     url_table = "\n".join(output[url] for url in sorted(output))
-    logger.debug(f"Available web server routes: \n{url_table}")
+    structlogger.debug(
+        "server.routes", event_info=f"Available web server routes: \n{url_table}"
+    )
 
     return output
 
@@ -171,6 +178,8 @@ def is_limit_reached(num_messages: int, limit: Optional[int]) -> bool:
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
+    _instance = None
+
     @classmethod
     def read_endpoints(cls, endpoint_file: Text) -> "AvailableEndpoints":
         """Read the different endpoints from a yaml file."""
@@ -184,6 +193,9 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        model_groups = read_property_config_from_endpoints_file(
+            endpoint_file, property_name="model_groups"
+        )
 
         return cls(
             nlg,
@@ -194,6 +206,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            model_groups,
         )
 
     def __init__(
@@ -206,6 +219,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        model_groups: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         """Create an `AvailableEndpoints` object."""
         self.model = model
@@ -216,6 +230,15 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.model_groups = model_groups
+
+    @classmethod
+    def get_instance(cls, endpoint_file: Optional[Text] = None) -> "AvailableEndpoints":
+        """Get the singleton instance of AvailableEndpoints."""
+        # Ensure that the instance is initialized only once.
+        if cls._instance is None:
+            cls._instance = cls.read_endpoints(endpoint_file)
+        return cls._instance
 
 
 def read_endpoints_from_path(
@@ -234,7 +257,7 @@ def read_endpoints_from_path(
     endpoints_config_path = cli_utils.get_validated_path(
         endpoints_path, "endpoints", DEFAULT_ENDPOINTS_PATH, True
     )
-    return AvailableEndpoints.read_endpoints(endpoints_config_path)
+    return AvailableEndpoints.get_instance(endpoints_config_path)
 
 
 def _lock_store_is_multi_worker_compatible(
@@ -263,17 +286,22 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
     """
 
     def _log_and_get_default_number_of_workers() -> int:
-        logger.debug(
-            f"Using the default number of Sanic workers ({DEFAULT_SANIC_WORKERS})."
+        structlogger.debug(
+            "server.worker.set_count",
+            number_of_workers=DEFAULT_SANIC_WORKERS,
+            event_info=f"Using the default number of Sanic workers "
+            f"({DEFAULT_SANIC_WORKERS}).",
         )
         return DEFAULT_SANIC_WORKERS
 
     try:
         env_value = int(os.environ.get(ENV_SANIC_WORKERS, DEFAULT_SANIC_WORKERS))
     except ValueError:
-        logger.error(
-            f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
-            f"to int ('{os.environ[ENV_SANIC_WORKERS]}')."
+        structlogger.error(
+            "server.worker.set_count.error",
+            number_of_workers=os.environ[ENV_SANIC_WORKERS],
+            event_info=f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
+            f"to int ('{os.environ[ENV_SANIC_WORKERS]}').",
         )
         return _log_and_get_default_number_of_workers()
 
@@ -281,20 +309,23 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         return _log_and_get_default_number_of_workers()
 
     if env_value < 1:
-        logger.debug(
-            f"Cannot set number of Sanic workers to the desired value "
-            f"({env_value}). The number of workers must be at least 1."
+        structlogger.debug(
+            "server.worker.set_count.error_less_than_one",
+            number_of_workers=env_value,
+            event_info=f"Cannot set number of Sanic workers to the desired value "
+            f"({env_value}). The number of workers must be at least 1.",
         )
         return _log_and_get_default_number_of_workers()
 
     if _lock_store_is_multi_worker_compatible(lock_store):
-        logger.debug(f"Using {env_value} Sanic workers.")
+        structlogger.debug(f"Using {env_value} Sanic workers.")
         return env_value
 
-    logger.debug(
-        f"Unable to assign desired number of Sanic workers ({env_value}) as "
+    structlogger.debug(
+        "server.worker.set_count.error_no_lock_store",
+        event_info=f"Unable to assign desired number of Sanic workers ({env_value}) as "
         f"no `RedisLockStore` or custom `LockStore` endpoint "
-        f"configuration has been found."
+        f"configuration has been found.",
     )
     return _log_and_get_default_number_of_workers()
 

rasa/dialogue_understanding/commands/__init__.py

@@ -33,6 +33,9 @@ from rasa.dialogue_understanding.commands.session_start_command import (
     SessionStartCommand,
 )
 from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
+from rasa.dialogue_understanding.commands.repeat_bot_messages_command import (
+    RepeatBotMessagesCommand,
+)
 
 __all__ = [
     "Command",
@@ -53,5 +56,6 @@ __all__ = [
     "ChangeFlowCommand",
     "SessionStartCommand",
     "SessionEndCommand",
+    "RepeatBotMessagesCommand",
     "RestartCommand",
 ]

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RepeatBotMessagesCommand(Command):
+    """A command to indicate that the bot should repeat its last messages."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "repeat"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RepeatBotMessagesCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return RepeatBotMessagesCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+        Get all the bot utterances until last user utterance and repeat them.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(RepeatBotMessagesPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RepeatBotMessagesCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/generator/single_step/command_prompt_template.jinja2

@@ -41,6 +41,9 @@ Based on this information generate a list of actions you want to take. Your job
 * Responding to knowledge-oriented user messages, described by "SearchAndReply()"
 * Responding to a casual, non-task-oriented user message, described by "ChitChat()".
 * Handing off to a human, in case the user seems frustrated or explicitly asks to speak to one, described by "HumanHandoff()".
+{% if is_repeat_command_enabled %}
+* Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
+{% endif %}
 
 ===
 Write out the actions you want to take, one per line, in the order they should take place.

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -16,6 +16,7 @@ from rasa.dialogue_understanding.commands import (
     KnowledgeAnswerCommand,
     ClarifyCommand,
     CannotHandleCommand,
+    RepeatBotMessagesCommand,
 )
 from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
@@ -50,6 +51,7 @@ from rasa.shared.utils.llm import (
     sanitize_message_for_prompt,
 )
 from rasa.utils.log_utils import log_llm
+from rasa.utils.beta import ensure_beta_feature_is_enabled, BetaNotEnabledException
 
 COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
 
@@ -293,6 +295,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         knowledge_re = re.compile(r"SearchAndReply\(\)")
         humand_handoff_re = re.compile(r"HumanHandoff\(\)")
         clarify_re = re.compile(r"Clarify\(([a-zA-Z0-9_, ]+)\)")
+        repeat_re = re.compile(r"RepeatLastBotMessages\(\)")
 
         for action in actions.strip().splitlines():
             if match := slot_set_re.search(action):
@@ -319,6 +322,8 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 commands.append(KnowledgeAnswerCommand())
             elif humand_handoff_re.search(action):
                 commands.append(HumanHandoffCommand())
+            elif repeat_re.search(action):
+                commands.append(RepeatBotMessagesCommand())
             elif match := clarify_re.search(action):
                 options = sorted([opt.strip() for opt in match.group(1).split(",")])
                 valid_options = [
@@ -393,6 +398,20 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
+            "is_repeat_command_enabled": self.is_repeat_command_enabled(),
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
+
+    def is_repeat_command_enabled(self) -> bool:
+        """Check for feature flag"""
+        RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME = "RASA_PRO_BETA_REPEAT_COMMAND"
+        try:
+            ensure_beta_feature_is_enabled(
+                "Repeat Command",
+                env_flag=RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME,
+            )
+        except BetaNotEnabledException:
+            return False
+
+        return True

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -217,6 +217,11 @@ flows:
               - action: utter_internal_error_rasa
                 next: END
 
+  pattern_repeat_bot_messages:
+    description: Voice conversation repair pattern to repeat bot messages
+    name: pattern repeat bot messages
+    steps:
+      - action: action_repeat_bot_messages
 
   pattern_restart:
     description: Flow for restarting the conversation

rasa/dialogue_understanding/patterns/repeat.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_REPEAT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "repeat_bot_messages"
+
+
+@dataclass
+class RepeatBotMessagesPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added when bot messages should be repeated"""
+
+    flow_id: str = FLOW_PATTERN_REPEAT
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_REPEAT
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> RepeatBotMessagesPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return RepeatBotMessagesPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/e2e_test/utils/io.py

@@ -506,6 +506,8 @@ def transform_results_output_to_yaml(yaml_string: str) -> str:
             result.append(s)
         elif s.startswith("\n"):
             result.append(s.strip())
+        elif s.strip().startswith("#"):
+            continue
         else:
             result.append(s)
     return "".join(result)

rasa/model_manager/config.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+SERVER_BASE_WORKING_DIRECTORY = os.environ.get(
+    "RASA_MODEL_SERVER_BASE_DIRECTORY", "working-data"
+)
+
+SERVER_BASE_URL = os.environ.get("RASA_MODEL_SERVER_BASE_URL", None)
+
+# defaults to storing on the local hard drive
+SERVER_MODEL_REMOTE_STORAGE = os.environ.get("RASA_REMOTE_STORAGE", None)
+
+# The path to the python executable that is running this script
+# we will use the same python to run training / bots
+RASA_PYTHON_PATH = sys.executable
+
+# the max limit for parallel training and bot run requests
+MAX_PARALLEL_TRAININGS = os.getenv("MAX_PARALLEL_TRAININGS", 10)