rasa-pro 3.11.4__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/core/processor.py

@@ -1,62 +1,84 @@
-import inspect
 import copy
+import inspect
 import logging
-import structlog
 import os
 import re
-from pathlib import Path
 import tarfile
 import time
+from pathlib import Path
 from types import LambdaType
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
+
+import structlog
+
+import rasa.core.actions.action
+import rasa.core.tracker_store
+import rasa.core.utils
+import rasa.shared.core.trackers
+import rasa.shared.utils.io
+from rasa.core import jobs
+from rasa.core.actions.action import Action
 from rasa.core.actions.action_exceptions import ActionExecutionRejection
 from rasa.core.actions.forms import FormAction
+from rasa.core.channels.channel import (
+    CollectingOutputChannel,
+    OutputChannel,
+    UserMessage,
+)
+from rasa.core.constants import KEY_IS_CALM_SYSTEM, KEY_IS_COEXISTENCE_ASSISTANT
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
+from rasa.core.lock_store import LockStore
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.core.policies.policy import PolicyPrediction
 from rasa.dialogue_understanding.commands import (
+    CannotHandleCommand,
     Command,
     NoopCommand,
     SetSlotCommand,
-    CannotHandleCommand,
 )
+from rasa.dialogue_understanding.commands.utils import (
+    create_validate_frames_from_slot_set_events,
+)
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.utils import add_commands_to_message_parse_data
 from rasa.engine import loader
 from rasa.engine.constants import (
+    PLACEHOLDER_ENDPOINTS,
     PLACEHOLDER_MESSAGE,
     PLACEHOLDER_TRACKER,
-    PLACEHOLDER_ENDPOINTS,
 )
 from rasa.engine.runner.dask import DaskGraphRunner
+from rasa.engine.runner.interface import GraphRunner
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.engine.storage.storage import ModelMetadata
+from rasa.exceptions import ActionLimitReached, ModelNotFound
 from rasa.model import get_latest_model
 from rasa.plugin import plugin_manager
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.data import TrainingType, create_regex_pattern_reader
-import rasa.shared.utils.io
-import rasa.core.actions.action
-from rasa.core import jobs
-from rasa.core.actions.action import Action
-from rasa.core.channels.channel import (
-    CollectingOutputChannel,
-    OutputChannel,
-    UserMessage,
+from rasa.shared.constants import (
+    ASSISTANT_ID_KEY,
+    DEFAULT_SENDER_ID,
+    DOCS_URL_DOMAINS,
+    DOCS_URL_NLU_BASED_POLICIES,
+    RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT,
+    ROUTE_TO_CALM_SLOT,
+    UTTER_PREFIX,
 )
-import rasa.core.utils
-from rasa.core.policies.policy import PolicyPrediction
-from rasa.engine.runner.interface import GraphRunner
-from rasa.exceptions import ActionLimitReached, ModelNotFound
 from rasa.shared.core.constants import (
     ACTION_CORRECT_FLOW_SLOT,
-    SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-    SLOT_SILENCE_TIMEOUT,
-    USER_INTENT_RESTART,
+    ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
-    ACTION_EXTRACT_SLOTS,
+    SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
+    SLOT_SILENCE_TIMEOUT,
+    USER_INTENT_RESTART,
     USER_INTENT_SILENCE_TIMEOUT,
 )
 from rasa.shared.core.events import (
+    ActionExecuted,
     ActionExecutionRejected,
     BotUttered,
     Event,
@@ -64,37 +86,25 @@ from rasa.shared.core.events import (
     ReminderScheduled,
     SlotSet,
     UserUttered,
-    ActionExecuted,
-)
-from rasa.shared.constants import (
-    ASSISTANT_ID_KEY,
-    DOCS_URL_DOMAINS,
-    DEFAULT_SENDER_ID,
-    ROUTE_TO_CALM_SLOT,
-    DOCS_URL_NLU_BASED_POLICIES,
-    UTTER_PREFIX,
-    RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT,
 )
-from rasa.core.nlg import NaturalLanguageGenerator
-from rasa.core.lock_store import LockStore
-from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
-import rasa.core.tracker_store
-import rasa.core.actions.action
-import rasa.shared.core.trackers
+from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.data import TrainingType, create_regex_pattern_reader
 from rasa.shared.nlu.constants import (
     COMMANDS,
     ENTITIES,
+    FULL_RETRIEVAL_INTENT_NAME_KEY,
     INTENT,
     INTENT_NAME_KEY,
     INTENT_RESPONSE_KEY,
+    PREDICTED_COMMANDS,
     PREDICTED_CONFIDENCE_KEY,
-    FULL_RETRIEVAL_INTENT_NAME_KEY,
-    RESPONSE_SELECTOR,
     RESPONSE,
+    RESPONSE_SELECTOR,
     TEXT,
 )
 from rasa.shared.nlu.training_data.message import Message
+from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
@@ -198,10 +208,7 @@ class MessageProcessor:
             )
             return None
 
-        if not self.message_contains_commands(tracker.latest_message):
-            tracker = await self.run_action_extract_slots(
-                message.output_channel, tracker
-            )
+        tracker = await self.run_action_extract_slots(message.output_channel, tracker)
 
         await self._run_prediction_loop(message.output_channel, tracker)
 
@@ -215,7 +222,9 @@ class MessageProcessor:
         return None
 
     async def run_action_extract_slots(
-        self, output_channel: OutputChannel, tracker: DialogueStateTracker
+        self,
+        output_channel: OutputChannel,
+        tracker: DialogueStateTracker,
     ) -> DialogueStateTracker:
         """Run action to extract slots and update the tracker accordingly.
 
@@ -230,6 +239,10 @@ class MessageProcessor:
             ACTION_EXTRACT_SLOTS, self.domain, self.action_endpoint
         )
         metadata = await self._add_flows_to_metadata()
+        metadata[KEY_IS_CALM_SYSTEM] = self.message_contains_commands(
+            tracker.latest_message
+        )
+        metadata[KEY_IS_COEXISTENCE_ASSISTANT] = self._is_coexistence_assistant(tracker)
 
         extraction_events = await action_extract_slots.run(
             output_channel, self.nlg, tracker, self.domain, metadata
@@ -818,9 +831,7 @@ class MessageProcessor:
         return parse_data
 
     def _sanitize_message(self, message: UserMessage) -> UserMessage:
-        """Sanitize user message by removing prepended slashes before the
-        actual content.
-        """
+        """Sanitize user message by removing prepended slashes before the content."""
         # Regex pattern to match leading slashes and any whitespace before
         # actual content
         pattern = r"^[/\s]+"
@@ -898,9 +909,14 @@ class MessageProcessor:
             NLUCommandAdapter,
         )
 
+        message = Message(parse_data)
         commands = NLUCommandAdapter.convert_nlu_to_commands(
-            Message(parse_data), tracker, await self.get_flows(), self.domain
+            message, tracker, await self.get_flows(), self.domain
         )
+        add_commands_to_message_parse_data(
+            message, NLUCommandAdapter.__name__, commands
+        )
+        parse_data[PREDICTED_COMMANDS] = message.get(PREDICTED_COMMANDS, [])
 
         # if there are no converted commands and parsed data contains invalid intent
         # add CannotHandleCommand as fallback
@@ -921,9 +937,7 @@ class MessageProcessor:
         return [command.as_dict() for command in commands]
 
     def _contains_undefined_intent(self, message: Message) -> bool:
-        """Checks if the message contains an intent that is undefined
-        in the domain.
-        """
+        """Checks if the message contains an undefined intent."""
         intent_name = message.get(INTENT, {}).get("name")
         return intent_name is not None and intent_name not in self.domain.intents
 
@@ -987,6 +1001,8 @@ class MessageProcessor:
         if parse_data["entities"]:
             self._log_slots(tracker)
 
+        plugin_manager().hook.after_new_user_message(tracker=tracker)
+
         logger.debug(
             f"Logged UserUtterance - tracker now has {len(tracker.events)} events."
         )
@@ -1245,6 +1261,12 @@ class MessageProcessor:
         # events and return values are used to update
         # the tracker state after an action has been taken
         try:
+            validate_frames: List[ValidateSlotPatternFlowStackFrame] = []
+            # check if the last action was a correction action
+            # before validating the corrected slots
+            if tracker.latest_action_name == ACTION_CORRECT_FLOW_SLOT:
+                tracker, validate_frames = self.validate_corrected_slots(tracker)
+
             # Use temporary tracker as we might need to discard the policy events in
             # case of a rejection.
             temporary_tracker = tracker.copy()
@@ -1256,6 +1278,12 @@ class MessageProcessor:
 
                 if isinstance(action, FormAction):
                     flows_metadata = await self._add_flows_to_metadata()
+                    flows_metadata[KEY_IS_CALM_SYSTEM] = self.message_contains_commands(
+                        temporary_tracker.latest_message
+                    )
+                    flows_metadata[KEY_IS_COEXISTENCE_ASSISTANT] = (
+                        self._is_coexistence_assistant(temporary_tracker)
+                    )
                     metadata = prediction.action_metadata or {}
                     metadata.update(flows_metadata)
 
@@ -1270,6 +1298,15 @@ class MessageProcessor:
                 events = await action.run(
                     output_channel, nlg, temporary_tracker, self.domain
                 )
+
+            if validate_frames:
+                stack = tracker.stack
+                for frame in validate_frames:
+                    stack.push(frame)
+                new_events = tracker.create_stack_updated_events(stack)
+                tracker.update_with_events(new_events)
+
+            self._log_action_and_events_on_tracker(tracker, action, events, prediction)
         except ActionExecutionRejection:
             events = [
                 ActionExecutionRejected(
@@ -1278,7 +1315,7 @@ class MessageProcessor:
             ]
             tracker.update(events[0])
             return self.should_predict_another_action(action.name())
-        except Exception:
+        except Exception as e:
             structlogger.exception(
                 "rasa.core.processor.run_action.exception",
                 event_info=f"Encountered an exception while "
@@ -1287,9 +1324,15 @@ class MessageProcessor:
                 f"Please check the logs of your action server for "
                 f"more information.",
             )
+            error_messge = str(e)
             events = []
-
-        self._log_action_on_tracker(tracker, action, events, prediction)
+            self._log_action_prediction_on_tracker(
+                tracker,
+                action,
+                prediction,
+                was_successful=False,
+                error_message=error_messge,
+            )
 
         if any(isinstance(e, UserUttered) for e in events):
             logger.debug(
@@ -1305,10 +1348,10 @@ class MessageProcessor:
             self._log_slots(tracker)
 
         await self.execute_side_effects(events, tracker, output_channel)
-
+        plugin_manager().hook.after_action_executed(tracker=tracker)
         return self.should_predict_another_action(action.name())
 
-    def _log_action_on_tracker(
+    def _log_action_and_events_on_tracker(
         self,
         tracker: DialogueStateTracker,
         action: Action,
@@ -1325,16 +1368,9 @@ class MessageProcessor:
             isinstance(event, ActionExecutionRejected) for event in events
         )
         if not action_was_rejected_manually:
-            structlogger.debug(
-                "processor.actions.policy_prediction",
-                prediction_events=copy.deepcopy(prediction.events),
-                policy_name=prediction.policy_name,
-                action_name=action.name(),
+            self._log_action_prediction_on_tracker(
+                tracker, action, prediction, was_successful=True, error_message=None
             )
-            tracker.update_with_events(prediction.events)
-
-            # log the action and its produced events
-            tracker.update(action.event_for_successful_execution(prediction))
 
         structlogger.debug(
             "processor.actions.log",
@@ -1343,6 +1379,29 @@ class MessageProcessor:
         )
         tracker.update_with_events(events)
 
+    def _log_action_prediction_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        action: Action,
+        prediction: PolicyPrediction,
+        was_successful: bool,
+        error_message: Optional[str],
+    ) -> None:
+        structlogger.debug(
+            "processor.actions.policy_prediction",
+            prediction_events=copy.deepcopy(prediction.events),
+            policy_name=prediction.policy_name,
+            action_name=action.name(),
+        )
+        tracker.update_with_events(prediction.events)
+
+        # log the action and its produced events
+        tracker.update(
+            action.event_for_successful_execution(
+                prediction, was_successful, error_message
+            )
+        )
+
     def _has_session_expired(self, tracker: DialogueStateTracker) -> bool:
         """Determine whether the latest session in `tracker` has expired.
 
@@ -1441,25 +1500,59 @@ class MessageProcessor:
         return len(filtered_commands) > 0
 
     def _is_calm_assistant(self) -> bool:
-        """Inspects the nodes of the graph schema to determine whether
-        any node is associated with the `FlowPolicy`, which is indicative of a
+        """Inspects the nodes of the graph schema to decide if we are in CALM.
+
+        To determine whether we are in CALM mode, we check if any node is
+        associated with the `FlowPolicy`, which is indicative of a
         CALM assistant setup.
 
         Returns:
             bool: True if any node in the graph schema uses `FlowPolicy`.
         """
+        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
+        return self._is_component_present_in_graph_nodes(flow_policy_class_path)
+
+    @staticmethod
+    def _is_coexistence_assistant(tracker: DialogueStateTracker) -> bool:
+        """Inspect the tracker to decide if we are in coexistence.
+
+        Returns:
+            bool: True if the tracker contains the routine slot.
+        """
+        return tracker.slots.get(ROUTE_TO_CALM_SLOT) is not None
+
+    def _is_component_present_in_graph_nodes(self, component_path: Text) -> bool:
+        """Check if a component is present in the graph nodes.
+
+        Args:
+            component_path: The path of the component to check for.
+
+        Returns:
+            `True` if the component is present in the graph nodes, `False` otherwise.
+        """
         # Get the graph schema's nodes from the graph runner.
         nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
 
-        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
-        # Iterate over the nodes and check if any node uses `FlowPolicy`.
         for node_name, schema_node in nodes.items():
             if (
                 schema_node.uses is not None
                 and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
-                == flow_policy_class_path
+                == component_path
             ):
                 return True
 
-        # Return False if no node is found using `FlowPolicy`.
         return False
+
+    def validate_corrected_slots(
+        self,
+        tracker: DialogueStateTracker,
+    ) -> Tuple[DialogueStateTracker, List[ValidateSlotPatternFlowStackFrame]]:
+        """Validate the slots that were corrected in the tracker."""
+        prior_tracker_events = list(reversed(tracker.events))
+        tracker, validate_frames = create_validate_frames_from_slot_set_events(
+            tracker,
+            prior_tracker_events,
+            should_break=True,
+        )
+
+        return tracker, validate_frames

rasa/core/run.py

@@ -19,7 +19,6 @@ from typing import (
 
 from sanic import Sanic
 from sanic.worker.loader import AppLoader
-from rasa.core.channels.development_inspector import DevelopmentInspectProxy
 
 import rasa.core.utils
 import rasa.shared.utils.common
@@ -33,6 +32,7 @@ from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
+from rasa.core.channels.development_inspector import DevelopmentInspectProxy
 from rasa.core.persistor import StorageType
 from rasa.core.utils import AvailableEndpoints
 from rasa.plugin import plugin_manager
@@ -283,9 +283,10 @@ def serve_application(
         endpoints.lock_store if endpoints else None
     )
 
-    telemetry.track_server_start(
-        input_channels, endpoints, model_path, number_of_workers, enable_api
-    )
+    if not inspect:
+        telemetry.track_server_start(
+            input_channels, endpoints, model_path, number_of_workers, enable_api
+        )
 
     rasa.utils.common.update_sanic_log_level(
         log_file, use_syslog, syslog_address, syslog_port, syslog_protocol

rasa/core/secrets_manager/endpoints.py

@@ -2,15 +2,14 @@ import logging
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union, cast
 
-from rasa.shared.exceptions import RasaException
-from rasa.utils.endpoints import EndpointConfig
-
 from rasa.core.secrets_manager.constants import (
     SECRET_KEY_LABEL,
     SECRET_MANAGER_PREFIX,
     SOURCE_KEY_LABEL,
     SUPPORTED_SECRET_MANAGERS,
 )
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
 
 logger = logging.getLogger(__name__)
 

rasa/core/secrets_manager/factory.py

@@ -1,9 +1,6 @@
 import os
 from typing import Optional, Text, cast
 
-from rasa.shared.exceptions import RasaException
-from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
-
 from rasa.core.secrets_manager.constants import (
     SECRET_MANAGER_ENV_NAME,
     VAULT_DEFAULT_RASA_SECRETS_PATH,
@@ -29,6 +26,8 @@ from rasa.core.secrets_manager.vault import (
     VaultSecretManagerNonStrictConfig,
     VaultSecretsManager,
 )
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
 
 
 def create(config: SecretManagerConfig) -> Optional[SecretsManager]:

rasa/core/secrets_manager/secret_manager.py

@@ -5,14 +5,13 @@ import copy
 import logging
 from typing import Any, ClassVar, Dict, List, Optional, Text, cast
 
-from rasa.shared.exceptions import RasaException
-from rasa.utils.endpoints import EndpointConfig
-
 from rasa.core.secrets_manager.endpoints import (
     CredentialsLocation,
     EndpointReader,
     EndpointTrait,
 )
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
 from rasa.utils.singleton import Singleton
 
 logger = logging.getLogger(__name__)

rasa/core/secrets_manager/vault.py

@@ -9,8 +9,6 @@ from typing import Any, Dict, Optional, Text, Union, cast
 import hvac.exceptions
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.interval import IntervalTrigger
-from rasa.shared.exceptions import RasaException
-from rasa.utils.endpoints import EndpointConfig
 
 from rasa.core.secrets_manager.constants import (
     TRACKER_STORE_ENDPOINT_TYPE,
@@ -25,6 +23,8 @@ from rasa.core.secrets_manager.endpoints import (
     TrackerStoreEndpointValidator,
 )
 from rasa.core.secrets_manager.secret_manager import SecretManagerConfig, SecretsManager
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
 
 logger = logging.getLogger(__name__)
 

rasa/core/test.py

@@ -1,73 +1,72 @@
 import logging
 import os
-from pathlib import Path
 import tempfile
 import warnings as pywarnings
 from collections import defaultdict, namedtuple
-from typing import Any, Dict, List, Optional, Text, Tuple, TYPE_CHECKING, cast
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, cast
 
+import rasa.shared.utils.io
 from rasa import telemetry
+from rasa.constants import PERCENTAGE_KEY, RESULTS_FILE
+from rasa.core.actions.action import ActionRetrieveResponse
+from rasa.core.channels import UserMessage
 from rasa.core.constants import (
     CONFUSION_MATRIX_STORIES_FILE,
-    REPORT_STORIES_FILE,
     FAILED_STORIES_FILE,
-    SUCCESSFUL_STORIES_FILE,
+    REPORT_STORIES_FILE,
     STORIES_WITH_WARNINGS_FILE,
+    SUCCESSFUL_STORIES_FILE,
 )
-from rasa.core.channels import UserMessage
 from rasa.core.policies.policy import PolicyPrediction
+from rasa.exceptions import ActionLimitReached
+from rasa.nlu.constants import (
+    RESPONSE_SELECTOR_DEFAULT_INTENT,
+    RESPONSE_SELECTOR_PROPERTY_NAME,
+    RESPONSE_SELECTOR_RETRIEVAL_INTENTS,
+    TOKENS_NAMES,
+)
 from rasa.nlu.test import EntityEvaluationResult, evaluate_entities
 from rasa.nlu.tokenizers.tokenizer import Token
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
 from rasa.shared.core.constants import (
-    POLICIES_THAT_EXTRACT_ENTITIES,
     ACTION_UNLIKELY_INTENT_NAME,
+    POLICIES_THAT_EXTRACT_ENTITIES,
 )
-from rasa.shared.exceptions import RasaException
-import rasa.shared.utils.io
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import ActionExecuted, EntitiesAdded, SlotSet, UserUttered
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.story_writer.yaml_story_writer import (
     YAMLStoryWriter,
 )
 from rasa.shared.core.training_data.structures import StoryStep
-from rasa.shared.core.domain import Domain
-from rasa.nlu.constants import (
-    RESPONSE_SELECTOR_DEFAULT_INTENT,
-    RESPONSE_SELECTOR_RETRIEVAL_INTENTS,
-    TOKENS_NAMES,
-    RESPONSE_SELECTOR_PROPERTY_NAME,
-)
+from rasa.shared.exceptions import RasaException
+from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import (
-    INTENT,
     ENTITIES,
-    ENTITY_ATTRIBUTE_VALUE,
-    ENTITY_ATTRIBUTE_START,
     ENTITY_ATTRIBUTE_END,
-    EXTRACTOR,
+    ENTITY_ATTRIBUTE_START,
+    ENTITY_ATTRIBUTE_TEXT,
     ENTITY_ATTRIBUTE_TYPE,
-    INTENT_RESPONSE_KEY,
+    ENTITY_ATTRIBUTE_VALUE,
+    EXTRACTOR,
+    FULL_RETRIEVAL_INTENT_NAME_KEY,
+    INTENT,
     INTENT_NAME_KEY,
+    INTENT_RESPONSE_KEY,
     RESPONSE,
     RESPONSE_SELECTOR,
-    FULL_RETRIEVAL_INTENT_NAME_KEY,
     TEXT,
-    ENTITY_ATTRIBUTE_TEXT,
 )
-from rasa.constants import RESULTS_FILE, PERCENTAGE_KEY
-from rasa.shared.core.events import ActionExecuted, EntitiesAdded, UserUttered, SlotSet
-from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.training_data.formats.readerwriter import TrainingDataWriter
-from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.io import DEFAULT_ENCODING
 from rasa.utils.tensorflow.constants import QUERY_INTENT_KEY, SEVERITY_KEY
-from rasa.exceptions import ActionLimitReached
-
-from rasa.core.actions.action import ActionRetrieveResponse
 
 if TYPE_CHECKING:
     from rasa.core.agent import Agent
     from rasa.core.processor import MessageProcessor
+    from rasa.shared.core.events import EntityPrediction, Event
     from rasa.shared.core.generator import TrainingDataGenerator
-    from rasa.shared.core.events import Event, EntityPrediction
 
 logger = logging.getLogger(__name__)
 
@@ -1226,6 +1225,7 @@ def _plot_story_evaluation(
     """Plot a confusion matrix of story evaluation."""
     from sklearn.metrics import confusion_matrix
     from sklearn.utils.multiclass import unique_labels
+
     from rasa.utils.plotting import plot_confusion_matrix
 
     confusion_matrix_filename = CONFUSION_MATRIX_STORIES_FILE