rasa-pro 3.8.17__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/core/run.py

@@ -1,8 +1,10 @@
 import asyncio
 import logging
-import uuid
-import platform
 import os
+import platform
+import uuid
+import warnings
+from asyncio import AbstractEventLoop
 from functools import partial
 from typing import (
     Any,
@@ -15,11 +17,14 @@ from typing import (
     Dict,
 )
 
+from sanic import Sanic
+from sanic.worker.loader import AppLoader
+
 import rasa.core.utils
-from rasa.plugin import plugin_manager
-from rasa.shared.exceptions import RasaException
 import rasa.shared.utils.common
+import rasa.shared.utils.io
 import rasa.utils
+from rasa.utils import licensing
 import rasa.utils.common
 import rasa.utils.io
 from rasa import server, telemetry
@@ -29,10 +34,8 @@ from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.utils import AvailableEndpoints
-import rasa.shared.utils.io
-from sanic import Sanic
-from asyncio import AbstractEventLoop
-
+from rasa.plugin import plugin_manager
+from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger()  # get the root logger
@@ -84,6 +87,10 @@ def _create_single_channel(channel: Text, credentials: Dict[Text, Any]) -> Any:
 
 def _create_app_without_api(cors: Optional[Union[Text, List[Text]]] = None) -> Sanic:
     app = Sanic("rasa_core_no_api", configure_logging=False)
+
+    # Reset Sanic warnings filter that allows the triggering of Sanic warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")
+
     server.add_root_route(app)
     server.configure_cors(app, cors)
     return app
@@ -126,19 +133,24 @@ def configure_app(
     )
 
     if enable_api:
-        app = server.create_app(
-            cors_origins=cors,
-            auth_token=auth_token,
-            response_timeout=response_timeout,
-            jwt_secret=jwt_secret,
-            jwt_private_key=jwt_private_key,
-            jwt_method=jwt_method,
-            endpoints=endpoints,
+        loader = AppLoader(
+            factory=partial(
+                server.create_app,
+                cors_origins=cors,
+                auth_token=auth_token,
+                response_timeout=response_timeout,
+                jwt_secret=jwt_secret,
+                jwt_private_key=jwt_private_key,
+                jwt_method=jwt_method,
+                endpoints=endpoints,
+            )
         )
     else:
-        app = _create_app_without_api(cors)
+        loader = AppLoader(factory=partial(_create_app_without_api, cors))
 
+    app = loader.load()
     app.config.KEEP_ALIVE_TIMEOUT = keep_alive_timeout
+
     if _is_apple_silicon_system() or not use_uvloop:
         app.config.USE_UVLOOP = False
         # some library still sets the loop to uvloop, even if disabled for sanic
@@ -154,18 +166,16 @@ def configure_app(
     if logger.isEnabledFor(logging.DEBUG):
         rasa.core.utils.list_routes(app)
 
-    async def configure_async_logging() -> None:
+    @app.main_process_start
+    async def configure_async_logging(running_app: Sanic) -> None:
         if logger.isEnabledFor(logging.DEBUG):
             rasa.utils.io.enable_async_loop_debugging(asyncio.get_event_loop())
 
-    app.add_task(configure_async_logging)
-
     if "cmdline" in {c.name() for c in input_channels}:
 
+        @app.after_server_start
         async def run_cmdline_io(running_app: Sanic) -> None:
             """Small wrapper to shut down the server once cmd io is done."""
-            await asyncio.sleep(1)  # allow server to start
-
             await console.record_messages(
                 server_url=constants.DEFAULT_SERVER_FORMAT.format("http", port),
                 sender_id=conversation_id,
@@ -174,12 +184,13 @@ def configure_app(
 
             logger.info("Killing Sanic server now.")
             running_app.stop()  # kill the sanic server
-            plugin_manager().hook.after_server_stop()
 
-        app.add_task(run_cmdline_io)
+    @app.after_server_stop
+    async def after_server_stop(running_app: Sanic) -> None:
+        plugin_manager().hook.after_server_stop()
 
     if server_listeners:
-        for (listener, event) in server_listeners:
+        for listener, event in server_listeners:
             app.register_listener(listener, event)
 
     return app
@@ -252,6 +263,10 @@ def serve_application(
         "before_server_start",
     )
 
+    app.register_listener(
+        licensing.validate_limited_server_license, "after_server_start"
+    )
+
     app.register_listener(close_resources, "after_server_stop")
 
     number_of_workers = rasa.core.utils.number_of_sanic_workers(
@@ -272,6 +287,7 @@ def serve_application(
         ssl=ssl_context,
         backlog=int(os.environ.get(ENV_SANIC_BACKLOG, "100")),
         workers=number_of_workers,
+        legacy=True,
     )
 
 

rasa/core/secrets_manager/endpoints.py

@@ -47,7 +47,7 @@ class CredentialsLocation:
 
     @staticmethod
     def is_credentials_location_instance(
-        value: Union[Text, "CredentialsLocation"]
+        value: Union[Text, "CredentialsLocation"],
     ) -> bool:
         """Check if the value is a CredentialsLocation.
 
@@ -85,7 +85,7 @@ class CredentialsLocation:
 
     @staticmethod
     def is_credentials_location_valid(
-        raw_credentials_location: Dict[Text, Text]
+        raw_credentials_location: Dict[Text, Text],
     ) -> bool:
         """Check if the configuration is a secret manager configuration.
 

rasa/core/secrets_manager/vault.py

@@ -124,7 +124,6 @@ class VaultEndpointConfigReader:
                 credentials_location.get_secret_manager_name()
                 == VAULT_SECRET_MANAGER_NAME
             ):
-
                 return VaultCredentialsLocation.from_credentials_location(
                     credentials_location=credentials_location
                 )
@@ -161,11 +160,10 @@ class VaultEndpointConfigReader:
                     credentials_location
                 )
             ):
-
                 if credentials_location.transit_key:
-                    transit_keys[
-                        credentials_location.secret_key
-                    ] = credentials_location.transit_key
+                    transit_keys[credentials_location.secret_key] = (
+                        credentials_location.transit_key
+                    )
 
         return transit_keys if transit_keys else None
 
@@ -357,9 +355,9 @@ class VaultTokenManager:
 
     def start(self) -> None:
         """Start refreshing the token if it is expiring."""
-        renew_response: Dict[
-            Text, Dict[Text, Any]
-        ] = self.client.auth.token.lookup_self()
+        renew_response: Dict[Text, Dict[Text, Any]] = (
+            self.client.auth.token.lookup_self()
+        )
         is_token_expiring = renew_response["data"]["renewable"]
         if is_token_expiring:
             refresh_interval_in_seconds = renew_response["data"]["creation_ttl"]

rasa/core/test.py

@@ -300,14 +300,14 @@ class EvaluationStore:
                 filter(
                     lambda x: x.get(ENTITY_ATTRIBUTE_TEXT) == text, self.entity_targets
                 ),
-                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required] # noqa: E501
+                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required]
             )
             entity_predictions = sorted(
                 filter(
                     lambda x: x.get(ENTITY_ATTRIBUTE_TEXT) == text,
                     self.entity_predictions,
                 ),
-                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required] # noqa: E501
+                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required]
             )
 
             i_pred, i_target = 0, 0
@@ -461,7 +461,7 @@ def _clean_entity_results(
     cleaned_entities = []
 
     for r in tuple(entity_results):
-        cleaned_entity: EntityPrediction = {ENTITY_ATTRIBUTE_TEXT: text}  # type: ignore[misc]  # noqa E501
+        cleaned_entity: EntityPrediction = {ENTITY_ATTRIBUTE_TEXT: text}  # type: ignore[misc]
         for k in (
             ENTITY_ATTRIBUTE_START,
             ENTITY_ATTRIBUTE_END,
@@ -706,7 +706,6 @@ async def _collect_action_executed_predictions(
     event: ActionExecuted,
     fail_on_prediction_errors: bool,
 ) -> Tuple[EvaluationStore, PolicyPrediction, Optional[EntityEvaluationResult]]:
-
     action_executed_eval_store = EvaluationStore()
 
     expected_action_name = event.action_name
@@ -825,7 +824,6 @@ async def _predict_tracker_actions(
     List[Dict[Text, Any]],
     List[EntityEvaluationResult],
 ]:
-
     processor = agent.processor
     if agent.processor is not None:
         processor = agent.processor

rasa/core/tracker_store.py

@@ -276,10 +276,10 @@ class TrackerStore:
     async def retrieve_full_tracker(
         self, conversation_id: Text
     ) -> Optional[DialogueStateTracker]:
-        """Retrieve method for fetching all tracker events across conversation sessions\
-        that may be overridden by specific tracker.
+        """Retrieve method for fetching all tracker events.
 
-        The default implementation uses `self.retrieve()`.
+        Fetches events across conversation sessions. The default implementation
+        uses `self.retrieve()`.
 
         Args:
             conversation_id: The conversation ID to retrieve the tracker for.
@@ -339,6 +339,28 @@ class TrackerStore:
         """Returns the set of values for the tracker store's primary key."""
         raise NotImplementedError()
 
+    async def count_conversations(self, after_timestamp: float = 0.0) -> int:
+        """Returns the number of conversations that have occurred after a timestamp.
+
+        By default, this method returns the number of conversations that
+        have occurred after the Unix epoch (i.e. timestamp 0). A conversation
+        is considered to have occurred after a timestamp if at least one event
+        happened after that timestamp.
+        """
+        tracker_keys = await self.keys()
+
+        conversation_count = 0
+        for key in tracker_keys:
+            tracker = await self.retrieve(key)
+            if tracker is None or not tracker.events:
+                continue
+
+            last_event = tracker.events[-1]
+            if last_event.timestamp >= after_timestamp:
+                conversation_count += 1
+
+        return conversation_count
+
     def deserialise_tracker(
         self, sender_id: Text, serialised_tracker: Union[Text, bytes]
     ) -> Optional[DialogueStateTracker]:
@@ -930,7 +952,7 @@ def _create_sequence(table_name: Text) -> "Sequence":
     """Creates a sequence object for a specific table name.
 
     If using Oracle you will need to create a sequence in your database,
-    as described here: https://rasa.com/docs/rasa/tracker-stores#sqltrackerstore
+    as described here: https://rasa.com/docs/rasa-pro/production/tracker-stores#sqltrackerstore
     Args:
         table_name: The name of the table, which gets a Sequence assigned
 
@@ -1045,6 +1067,8 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
     from sqlalchemy.orm import DeclarativeBase
 
     class Base(DeclarativeBase):
+        """Base class for all tracker store tables."""
+
         pass
 
     class SQLEvent(Base):
@@ -1113,7 +1137,6 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
                 sqlalchemy.exc.OperationalError,
                 sqlalchemy.exc.IntegrityError,
             ) as error:
-
                 logger.warning(error)
                 sleep(5)
 
@@ -1132,8 +1155,10 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
         login_db: Optional[Text] = None,
         query: Optional[Dict] = None,
     ) -> Union[Text, "URL"]:
-        """Build an SQLAlchemy `URL` object representing the parameters needed
-        to connect to an SQL database.
+        """Build an SQLAlchemy `URL` object.
+
+        The URL object represents the parameters needed to connect to an
+        SQL database.
 
         Args:
             dialect: SQL database type.
@@ -1260,11 +1285,24 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
             conversation_id, fetch_events_from_all_sessions=True
         )
 
+    async def count_conversations(self, after_timestamp: float = 0.0) -> int:
+        """Returns the number of conversations that have occurred after a timestamp.
+
+        By default, this method returns the number of conversations that
+        have occurred after the Unix epoch (i.e. timestamp 0).
+        """
+        with self.session_scope() as session:
+            query = (
+                session.query(self.SQLEvent.sender_id)
+                .distinct()
+                .filter(self.SQLEvent.timestamp >= after_timestamp)
+            )
+            return query.count()
+
     async def _retrieve(
         self, sender_id: Text, fetch_events_from_all_sessions: bool
     ) -> Optional[DialogueStateTracker]:
         with self.session_scope() as session:
-
             serialised_events = self._event_query(
                 session,
                 sender_id,
@@ -1290,6 +1328,7 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
         self, session: "Session", sender_id: Text, fetch_events_from_all_sessions: bool
     ) -> "Query":
         """Provide the query to retrieve the conversation events for a specific sender.
+
         The events are ordered by ID to ensure correct sequence of events.
         As `timestamp` is not guaranteed to be unique and low-precision (float), it
         cannot be used to order the events.
@@ -1637,9 +1676,7 @@ class AwaitableTrackerStore(TrackerStore):
         """Wrapper to call `retrieve` method of primary tracker store."""
         result = self._tracker_store.retrieve(sender_id)
         return (
-            await result
-            if isawaitable(result)
-            else result  # type: ignore[return-value]
+            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
         )
 
     async def keys(self) -> Iterable[Text]:
@@ -1658,7 +1695,5 @@ class AwaitableTrackerStore(TrackerStore):
         """Wrapper to call `retrieve_full_tracker` method of primary tracker store."""
         result = self._tracker_store.retrieve_full_tracker(conversation_id)
         return (
-            await result
-            if isawaitable(result)
-            else result  # type: ignore[return-value]
+            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
         )

rasa/core/train.py

@@ -34,9 +34,7 @@ async def train_comparison_models(
             for policy_config in policy_configs:
                 config_name = os.path.splitext(os.path.basename(policy_config))[0]
                 logging.info(
-                    "Starting to train {} round {}/{}"
-                    " with {}% exclusion"
-                    "".format(
+                    "Starting to train {} round {}/{} with {}% exclusion".format(
                         config_name, current_run, len(exclusion_percentages), percentage
                     )
                 )

rasa/core/training/interactive.py

@@ -3,6 +3,7 @@ import logging
 import os
 import textwrap
 import uuid
+import warnings
 from functools import partial
 from multiprocessing import Process
 from typing import (
@@ -336,7 +337,7 @@ async def _ask_questions(
 
 
 def _selection_choices_from_intent_prediction(
-    predictions: List[Dict[Text, Any]]
+    predictions: List[Dict[Text, Any]],
 ) -> List[Dict[Text, Any]]:
     """Given a list of ML predictions create a UI choice list."""
     sorted_intents = sorted(
@@ -762,7 +763,7 @@ async def _request_export_info() -> Tuple[Text, Text, Text]:
 
 
 def _split_conversation_at_restarts(
-    events: List[Dict[Text, Any]]
+    events: List[Dict[Text, Any]],
 ) -> List[List[Dict[Text, Any]]]:
     """Split a conversation at restart events.
 
@@ -1600,6 +1601,7 @@ def _serve_application(
     """Start a core server and attach the interactive learning IO."""
     endpoint = EndpointConfig(url=DEFAULT_SERVER_FORMAT.format("http", port))
 
+    @app.after_server_start
     async def run_interactive_io(running_app: Sanic) -> None:
         """Small wrapper to shut down the server once cmd io is done."""
         await record_messages(
@@ -1613,11 +1615,9 @@ def _serve_application(
 
         running_app.stop()  # kill the sanic server
 
-    app.add_task(run_interactive_io)
-
     update_sanic_log_level()
 
-    app.run(host="0.0.0.0", port=port)
+    app.run(host="0.0.0.0", port=port, legacy=True)
 
     return app
 
@@ -1626,6 +1626,9 @@ def start_visualization(image_path: Text, port: int) -> None:
     """Add routes to serve the conversation visualization files."""
     app = Sanic("rasa_interactive")
 
+    # Reset Sanic warnings filter that allows the triggering of Sanic warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")
+
     # noinspection PyUnusedLocal
     @app.exception(NotFound)
     async def ignore_404s(request: Request, exception: Exception) -> HTTPResponse:
@@ -1647,7 +1650,7 @@ def start_visualization(image_path: Text, port: int) -> None:
 
     update_sanic_log_level()
 
-    app.run(host="0.0.0.0", port=port, access_log=False)
+    app.run(host="0.0.0.0", port=port, access_log=False, legacy=True)
 
 
 def run_interactive_learning(

rasa/core/utils.py

@@ -73,8 +73,9 @@ def one_hot(hot_idx: int, length: int, dtype: Optional[Text] = None) -> np.ndarr
     """
     if hot_idx >= length:
         raise ValueError(
-            "Can't create one hot. Index '{}' is out "
-            "of range (length '{}')".format(hot_idx, length)
+            "Can't create one hot. Index '{}' is out of range (length '{}')".format(
+                hot_idx, length
+            )
         )
     r = np.zeros(length, dtype)
     r[hot_idx] = 1
@@ -159,12 +160,6 @@ def is_limit_reached(num_messages: int, limit: Optional[int]) -> bool:
     return limit is not None and num_messages >= limit
 
 
-def file_as_bytes(path: Text) -> bytes:
-    """Read in a file as a byte array."""
-    with open(path, "rb") as f:
-        return f.read()
-
-
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
@@ -216,7 +211,7 @@ class AvailableEndpoints:
 
 
 def read_endpoints_from_path(
-    endpoints_path: Optional[Union[Path, Text]] = None
+    endpoints_path: Optional[Union[Path, Text]] = None,
 ) -> AvailableEndpoints:
     """Get `AvailableEndpoints` object from specified path.
 
@@ -283,7 +278,7 @@ def replace_decimals_with_floats(obj: Any) -> Any:
 
 
 def _lock_store_is_multi_worker_compatible(
-    lock_store: Union[EndpointConfig, LockStore, None]
+    lock_store: Union[EndpointConfig, LockStore, None],
 ) -> bool:
     if isinstance(lock_store, InMemoryLockStore):
         return False

rasa/dialogue_understanding/coexistence/intent_based_router.py

@@ -19,6 +19,7 @@ from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import InvalidConfigException
@@ -111,6 +112,7 @@ class IntentBasedRouter(GraphComponent):
         messages: List[Message],
         flows: FlowsList,
         tracker: Optional[DialogueStateTracker] = None,
+        domain: Optional[Domain] = None,
     ) -> List[Message]:
         """Process a list of messages."""
         if tracker is None:
@@ -118,7 +120,7 @@ class IntentBasedRouter(GraphComponent):
             return messages
 
         for message in messages:
-            commands = await self.predict_commands(message, flows, tracker)
+            commands = await self.predict_commands(message, flows, tracker, domain)
             commands_dicts = [command.as_dict() for command in commands]
             message.set(COMMANDS, commands_dicts, add_to_output=True)
 
@@ -129,6 +131,7 @@ class IntentBasedRouter(GraphComponent):
         message: Message,
         flows: FlowsList,
         tracker: DialogueStateTracker,
+        domain: Optional[Domain] = None,
     ) -> List[Command]:
         if not tracker.has_coexistence_routing_slot:
             raise InvalidConfigException(
@@ -144,8 +147,8 @@ class IntentBasedRouter(GraphComponent):
             )
             return commands
         elif route_session_to_calm is True:
-            # don't set any commands so that the `LLMCommandGenerator` is triggered
-            # and can predict the actual commands.
+            # don't set any commands so that a `LLMBasedCommandGenerator` is
+            # triggered and can predict the actual commands.
             return []
         else:
             # If the session is assigned to DM1 add a `NoopCommand` to silence
@@ -156,7 +159,11 @@ class IntentBasedRouter(GraphComponent):
         self, message: Message, tracker: DialogueStateTracker, flows: FlowsList
     ) -> bool:
         """Check if the intent is part of a nlu trigger."""
-        commands = NLUCommandAdapter.convert_nlu_to_commands(message, tracker, flows)
+        commands = NLUCommandAdapter.convert_nlu_to_commands(
+            message,
+            tracker,
+            flows,
+        )
         return len(commands) > 0
 
     def _generate_command_using_intent(

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -13,7 +13,7 @@ from rasa.dialogue_understanding.coexistence.constants import (
 )
 from rasa.dialogue_understanding.commands import Command, SetSlotCommand
 from rasa.dialogue_understanding.commands.noop_command import NoopCommand
-from rasa.dialogue_understanding.generator.llm_command_generator import LLM_CONFIG_KEY
+from rasa.dialogue_understanding.generator.constants import LLM_CONFIG_KEY
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -196,7 +196,7 @@ class LLMBasedRouter(GraphComponent):
             structlogger.info("llm_based_router.predicated_commands", commands=commands)
             return commands
         elif route_session_to_calm is True:
-            # don't set any commands so that the `LLMCommandGenerator` is triggered
+            # don't set any commands so that a `LLMBasedCommandGenerator` is triggered
             # and can predict the actual commands.
             return []
         else:
@@ -231,7 +231,6 @@ class LLMBasedRouter(GraphComponent):
             return [SetSlotCommand(ROUTE_TO_CALM_SLOT, False)]
 
     def render_template(self, message: Message) -> str:
-
         inputs = {
             "user_message": message.get(TEXT),
             f"{CALM_ENTRY}_{STICKY}": self.config[CALM_ENTRY][STICKY],

rasa/dialogue_understanding/commands/__init__.py

@@ -26,6 +26,8 @@ from rasa.dialogue_understanding.commands.correct_slots_command import (
     CorrectSlotsCommand,
     CorrectedSlot,
 )
+from rasa.dialogue_understanding.commands.noop_command import NoopCommand
+from rasa.dialogue_understanding.commands.change_flow_command import ChangeFlowCommand
 
 __all__ = [
     "Command",
@@ -42,4 +44,6 @@ __all__ = [
     "CorrectSlotsCommand",
     "CorrectedSlot",
     "ErrorCommand",
+    "NoopCommand",
+    "ChangeFlowCommand",
 ]

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -59,3 +59,12 @@ class CannotHandleCommand(Command):
         else:
             stack.push(CannotHandlePatternFlowStackFrame())
         return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.reason)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CannotHandleCommand):
+            return False
+
+        return other.reason == self.reason

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -114,3 +114,12 @@ class CancelFlowCommand(Command):
             applied_events.append(FlowCancelled(user_frame.flow_id, user_frame.step_id))
 
         return applied_events + tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CancelFlowCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class ChangeFlowCommand(Command):
+    """A command to indicate a change of flows was requested by the command
+    generator."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "change_flow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ChangeFlowCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ChangeFlowCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        # the change flow command is not actually pushing anything to the tracker,
+        # but it is predicted by the MultiStepLLMCommandGenerator and used internally
+        return []

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -46,3 +46,12 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
         stack = tracker.stack
         stack.push(ChitchatPatternFlowStackFrame())
         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, ChitChatAnswerCommand):
+            return False
+
+        return True