rasa-pro 3.11.3a1.dev6__py3-none-any.whl → 3.11.4__py3-none-any.whl

rasa/engine/recipes/default_recipe.py

@@ -1,71 +1,65 @@
 from __future__ import annotations
 
 import copy
-import dataclasses
 import enum
 import logging
 import math
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Set, Text, Tuple, Type, Union
+from typing import Dict, Text, Any, Tuple, Type, Optional, List, Callable, Set, Union
+
+import dataclasses
 
-import rasa.shared.constants
 from rasa.core.featurizers.precomputation import (
-    CoreFeaturizationCollector,
     CoreFeaturizationInputConverter,
+    CoreFeaturizationCollector,
 )
-from rasa.core.policies.ensemble import DefaultPolicyPredictionEnsemble
+from rasa.graph_components.providers.flows_provider import FlowsProvider
 from rasa.dialogue_understanding.processor.command_processor_component import (
     CommandProcessorComponent,
 )
+from rasa.shared.exceptions import FileNotFoundException
+from rasa.core.policies.ensemble import DefaultPolicyPredictionEnsemble
+
+from rasa.engine.graph import (
+    GraphSchema,
+    GraphComponent,
+    SchemaNode,
+    GraphModelConfiguration,
+)
 from rasa.engine.constants import (
-    PLACEHOLDER_ENDPOINTS,
     PLACEHOLDER_IMPORTER,
     PLACEHOLDER_MESSAGE,
     PLACEHOLDER_TRACKER,
-)
-from rasa.engine.graph import (
-    GraphComponent,
-    GraphModelConfiguration,
-    GraphSchema,
-    SchemaNode,
+    PLACEHOLDER_ENDPOINTS,
 )
 from rasa.engine.recipes.recipe import Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.graph_components.converters.nlu_message_converter import NLUMessageConverter
+from rasa.graph_components.providers.domain_provider import DomainProvider
+from rasa.graph_components.providers.forms_provider import FormsProvider
+from rasa.graph_components.providers.responses_provider import ResponsesProvider
 from rasa.graph_components.providers.domain_for_core_training_provider import (
     DomainForCoreTrainingProvider,
 )
-from rasa.graph_components.providers.domain_provider import DomainProvider
-from rasa.graph_components.providers.flows_provider import FlowsProvider
-from rasa.graph_components.providers.forms_provider import FormsProvider
 from rasa.graph_components.providers.nlu_training_data_provider import (
     NLUTrainingDataProvider,
 )
-from rasa.graph_components.providers.responses_provider import ResponsesProvider
 from rasa.graph_components.providers.rule_only_provider import RuleOnlyDataProvider
 from rasa.graph_components.providers.story_graph_provider import StoryGraphProvider
 from rasa.graph_components.providers.training_tracker_provider import (
     TrainingTrackerProvider,
 )
-from rasa.shared.constants import (
-    ASSISTANT_ID_KEY,
-    CONFIG_LANGUAGE_KEY,
-    CONFIG_NAME_KEY,
-    CONFIG_PIPELINE_KEY,
-    CONFIG_POLICIES_KEY,
-)
+import rasa.shared.constants
+from rasa.shared.exceptions import RasaException, InvalidConfigException
+from rasa.shared.constants import ASSISTANT_ID_KEY
 from rasa.shared.data import TrainingType
-from rasa.shared.exceptions import (
-    FileNotFoundException,
-    InvalidConfigException,
-    RasaException,
-)
+from rasa.shared.utils.yaml import read_config_file
+
+from rasa.utils.tensorflow.constants import EPOCHS
 from rasa.shared.utils.common import (
     class_from_module_path,
     transform_collection_to_sentence,
 )
-from rasa.shared.utils.yaml import read_config_file
-from rasa.utils.tensorflow.constants import EPOCHS
 
 logger = logging.getLogger(__name__)
 
@@ -73,13 +67,13 @@ logger = logging.getLogger(__name__)
 DEFAULT_PREDICT_KWARGS = dict(constructor_name="load", eager=True, is_target=False)
 
 COMMENTS_FOR_KEYS = {
-    CONFIG_PIPELINE_KEY: (
+    "pipeline": (
         f"# # No configuration for the NLU pipeline was provided. The following "
         f"default pipeline was used to train your model.\n"
         f"# # If you'd like to customize it, uncomment and adjust the pipeline.\n"
         f"# # See {rasa.shared.constants.DOCS_URL_PIPELINE} for more information.\n"
     ),
-    CONFIG_POLICIES_KEY: (
+    "policies": (
         f"# # No configuration for policies was provided. The following default "
         f"policies were used to train your model.\n"
         f"# # If you'd like to customize them, uncomment and adjust the policies.\n"
@@ -88,10 +82,6 @@ COMMENTS_FOR_KEYS = {
 }
 
 
-GRAPH_NODE_RUN_PREFIX = "run_"
-GRAPH_NODE_TRAIN_PREFIX = "train_"
-
-
 class DefaultV1RecipeRegisterException(RasaException):
     """If you register a class which is not of type `GraphComponent`."""
 
@@ -204,12 +194,10 @@ class DefaultV1Recipe(Recipe):
     ) -> GraphModelConfiguration:
         """Converts the default config to graphs (see interface for full docstring)."""
         self._use_core = (
-            bool(config.get(CONFIG_POLICIES_KEY))
-            and not training_type == TrainingType.NLU
+            bool(config.get("policies")) and not training_type == TrainingType.NLU
         )
         self._use_nlu = (
-            bool(config.get(CONFIG_PIPELINE_KEY))
-            and not training_type == TrainingType.CORE
+            bool(config.get("pipeline")) and not training_type == TrainingType.CORE
         )
 
         if not self._use_nlu and training_type == TrainingType.NLU:
@@ -244,9 +232,9 @@ class DefaultV1Recipe(Recipe):
             predict_schema=GraphSchema(predict_nodes),
             training_type=training_type,
             assistant_id=config.get(ASSISTANT_ID_KEY),
-            language=config.get(CONFIG_LANGUAGE_KEY),
+            language=config.get("language"),
             core_target=core_target,
-            nlu_target=f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}",
+            nlu_target=f"run_{RegexMessageHandler.__name__}",
         )
 
     def _create_train_nodes(
@@ -329,7 +317,7 @@ class DefaultV1Recipe(Recipe):
             constructor_name="create",
             fn="provide",
             config={
-                "language": train_config.get(CONFIG_LANGUAGE_KEY),
+                "language": train_config.get("language"),
                 "persist": persist_nlu_data,
             },
             is_target=persist_nlu_data,
@@ -339,8 +327,8 @@ class DefaultV1Recipe(Recipe):
         last_run_node = "nlu_training_data_provider"
         preprocessors: List[Text] = []
 
-        for idx, config in enumerate(train_config[CONFIG_PIPELINE_KEY]):
-            component_name = config.pop(CONFIG_NAME_KEY)
+        for idx, config in enumerate(train_config["pipeline"]):
+            component_name = config.pop("name")
             component = self._from_registry(component_name)
             component_name = f"{component_name}{idx}"
 
@@ -463,7 +451,7 @@ class DefaultV1Recipe(Recipe):
         needs.update(self._get_model_provider_needs(train_nodes, component))
         needs["training_data"] = last_run_node
 
-        train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}"
+        train_node_name = f"train_{component_name}"
         train_nodes[train_node_name] = SchemaNode(
             needs=needs,
             uses=component,
@@ -481,10 +469,10 @@ class DefaultV1Recipe(Recipe):
         component_config: Dict[Text, Any],
     ) -> Dict[Text, Any]:
         from rasa.nlu.classifiers.mitie_intent_classifier import MitieIntentClassifier
+        from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor
         from rasa.nlu.classifiers.sklearn_intent_classifier import (
             SklearnIntentClassifier,
         )
-        from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor
 
         cli_args_mapping: Dict[Type[GraphComponent], List[Text]] = {
             MitieIntentClassifier: ["num_threads"],
@@ -532,7 +520,7 @@ class DefaultV1Recipe(Recipe):
 
         needs["training_data"] = last_run_node
 
-        node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}"
+        node_name = f"run_{component_name}"
         train_nodes[node_name] = SchemaNode(
             needs=needs,
             uses=component_class,
@@ -639,8 +627,8 @@ class DefaultV1Recipe(Recipe):
         )
 
         policy_with_end_to_end_support_used = False
-        for idx, config in enumerate(train_config[CONFIG_POLICIES_KEY]):
-            component_name = config.pop(CONFIG_NAME_KEY)
+        for idx, config in enumerate(train_config["policies"]):
+            component_name = config.pop("name")
             component = self._from_registry(component_name)
 
             extra_config_from_cli = self._extra_config_from_cli(
@@ -659,7 +647,7 @@ class DefaultV1Recipe(Recipe):
                 needs["precomputations"] = "end_to_end_features_provider"
             # during core training we use a stripped down version of the domain
             needs["domain"] = "domain_for_core_training_provider"
-            train_nodes[f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}{idx}"] = SchemaNode(
+            train_nodes[f"train_{component_name}{idx}"] = SchemaNode(
                 needs=needs,
                 uses=component.clazz,
                 constructor_name="load" if self._is_finetuning else "create",
@@ -734,9 +722,7 @@ class DefaultV1Recipe(Recipe):
         if self._use_core:
             domain_needs["domain"] = "domain_provider"
 
-        regex_handler_node_name = (
-            f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}"
-        )
+        regex_handler_node_name = f"run_{RegexMessageHandler.__name__}"
         predict_nodes[regex_handler_node_name] = SchemaNode(
             **DEFAULT_PREDICT_KWARGS,
             needs={"messages": last_run_nlu_node, **domain_needs},
@@ -776,8 +762,8 @@ class DefaultV1Recipe(Recipe):
             resource=Resource("domain_provider"),
         )
 
-        for idx, config in enumerate(predict_config[CONFIG_PIPELINE_KEY]):
-            component_name = config.pop(CONFIG_NAME_KEY)
+        for idx, config in enumerate(predict_config["pipeline"]):
+            component_name = config.pop("name")
             component = self._from_registry(component_name)
             component_name = f"{component_name}{idx}"
             if self.ComponentType.MODEL_LOADER in component.types:
@@ -844,10 +830,10 @@ class DefaultV1Recipe(Recipe):
         item_config: Dict[Text, Any],
         from_resource: bool = False,
     ) -> Text:
-        train_node_name = f"{GRAPH_NODE_RUN_PREFIX}{node_name}"
+        train_node_name = f"run_{node_name}"
         resource = None
         if from_resource:
-            train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{node_name}"
+            train_node_name = f"train_{node_name}"
             resource = Resource(train_node_name)
 
         return self._add_nlu_predict_node(
@@ -866,7 +852,7 @@ class DefaultV1Recipe(Recipe):
         component_name: Text,
         last_run_node: Text,
     ) -> Text:
-        node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}"
+        node_name = f"run_{component_name}"
 
         needs = self._get_needs_from_args(node.uses, "process")
         needs.update(self._get_model_provider_needs(predict_nodes, node.uses))
@@ -933,12 +919,12 @@ class DefaultV1Recipe(Recipe):
         rule_policy_resource = None
         policies: List[Text] = []
 
-        for idx, config in enumerate(predict_config[CONFIG_POLICIES_KEY]):
-            component_name = config.pop(CONFIG_NAME_KEY)
+        for idx, config in enumerate(predict_config["policies"]):
+            component_name = config.pop("name")
             component = self._from_registry(component_name)
 
-            train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}{idx}"
-            node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}{idx}"
+            train_node_name = f"train_{component_name}{idx}"
+            node_name = f"run_{component_name}{idx}"
 
             from rasa.core.policies.rule_policy import RulePolicy
 

rasa/engine/recipes/graph_recipe.py

@@ -1,17 +1,16 @@
 import logging
-from typing import Any, Dict, Text, Tuple
 
-from rasa.engine.graph import GraphModelConfiguration, GraphSchema
 from rasa.engine.recipes.recipe import Recipe
-from rasa.shared.constants import (
-    ASSISTANT_ID_KEY,
-    CONFIG_LANGUAGE_KEY,
-    DOCS_URL_GRAPH_RECIPE,
-)
+from rasa.engine.graph import GraphModelConfiguration
+from rasa.shared.constants import DOCS_URL_GRAPH_RECIPE, ASSISTANT_ID_KEY
 from rasa.shared.data import TrainingType
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.common import mark_as_experimental_feature
 from rasa.shared.utils.io import raise_warning
+from rasa.engine.graph import GraphSchema
+
+from typing import Dict, Text, Any, Tuple
+
 
 logger = logging.getLogger(__name__)
 
@@ -73,7 +72,7 @@ class GraphV1Recipe(Recipe):
             predict_schema=GraphSchema.from_dict(config.get("predict_schema")),
             training_type=training_type,
             assistant_id=config.get(ASSISTANT_ID_KEY),
-            language=config.get(CONFIG_LANGUAGE_KEY),
+            language=config.get("language"),
             core_target=core_target,
             nlu_target=nlu_target,
         )

rasa/model_manager/runner_service.py

@@ -207,7 +207,6 @@ def start_bot_process(
         "--credentials",
         f"{bot_base_path}/credentials.yml",
         "--debug",
-        "--inspect",
         f"--port={port}",
         "--model",
         f"{bot_base_path}/models",

rasa/model_manager/socket_bridge.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any, Dict, Optional
 
 from socketio import AsyncServer
@@ -93,7 +92,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
 
     @sio.on("*")
     async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
-        """Bridge messages between user and bot.
+        """ "Bridge messages between user and bot.
 
         Both incoming user messages to the bot_url and
         bot responses sent back to the client need to
@@ -112,7 +111,7 @@ async def create_bridge_client(
 ) -> AsyncClient:
     """Create a new socket bridge client.
 
-    Forwards messages coming from the bot to the user.
+    Forwards messages comming from the bot to the user.
     """
     client = AsyncClient()
 
@@ -130,11 +129,6 @@ async def create_bridge_client(
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
         await sio.emit("bot_message", data, room=sid)
 
-    @client.event  # type: ignore[misc]
-    async def tracker(data: Dict[str, Any]) -> None:
-        structlogger.debug("model_runner.tracker_message", deployment_id=deployment_id)
-        await sio.emit("tracker", json.loads(data), room=sid)
-
     @client.event  # type: ignore[misc]
     async def disconnect() -> None:
         structlogger.debug(

rasa/model_manager/warm_rasa_process.py

@@ -1,16 +1,12 @@
-import os
 import shlex
 import subprocess
-import uuid
-from dataclasses import dataclass
+from rasa.__main__ import main
+import os
 from typing import List
-
 import structlog
+from dataclasses import dataclass
+import uuid
 
-from rasa.__main__ import main
-from rasa.dialogue_understanding.constants import (
-    RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
-)
 from rasa.model_manager import config
 from rasa.model_manager.utils import ensure_base_directory_exists, logs_path
 
@@ -47,7 +43,6 @@ def _create_warm_rasa_process() -> WarmRasaProcess:
 
     envs = os.environ.copy()
     envs["RASA_TELEMETRY_ENABLED"] = "false"
-    envs[RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME] = "true"
 
     log_id = uuid.uuid4().hex
     log_path = logs_path(log_id)

rasa/model_training.py

@@ -23,7 +23,6 @@ from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.components import FingerprintStatus
 from rasa.engine.training.graph_trainer import GraphTrainer
-from rasa.shared.constants import CONFIG_RECIPE_KEY
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import SlotSet
 from rasa.shared.core.training_data.structures import StoryGraph
@@ -305,7 +304,7 @@ async def _train_graph(
     is_finetuning = model_to_finetune is not None
 
     config = file_importer.get_config()
-    recipe = Recipe.recipe_for_name(config.get(CONFIG_RECIPE_KEY))
+    recipe = Recipe.recipe_for_name(config.get("recipe"))
     config, _missing_keys, _configured_keys = recipe.auto_configure(
         file_importer.get_config_file_for_auto_config(),
         config,

rasa/nlu/classifiers/fallback_classifier.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
-import copy
 import logging
 from typing import Any, List, Text, Dict, Type, Union, Tuple, Optional
 
@@ -185,8 +184,6 @@ def undo_fallback_prediction(prediction: Dict[Text, Any]) -> Dict[Text, Any]:
     if len(intent_ranking) < 2:
         return prediction
 
-    prediction = copy.deepcopy(prediction)
     prediction[INTENT] = intent_ranking[1]
     prediction[INTENT_RANKING_KEY] = prediction[INTENT_RANKING_KEY][1:]
-
     return prediction

rasa/server.py

@@ -62,9 +62,11 @@ from rasa.shared.constants import (
     DOCS_BASE_URL,
     DOCS_URL_TRAINING_DATA,
     TEST_STORIES_FILE_PREFIX,
+    DOCS_URL_FLOWS,
 )
 from rasa.shared.core.domain import Domain, InvalidDomain
 from rasa.shared.core.events import Event
+from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
     EventVerbosity,
@@ -72,6 +74,7 @@ from rasa.shared.core.trackers import (
 from rasa.shared.core.training_data.story_writer.yaml_story_writer import (
     YAMLStoryWriter,
 )
+from rasa.shared.exceptions import YamlException, RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.training_data.formats import RasaYAMLReader
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
@@ -1566,7 +1569,8 @@ def _nlu_training_payload_from_json(
     )
 
 
-def _validate_yaml_training_payload(yaml_text: Text) -> None:
+def _validate_nlu_training_data_payload(yaml_text: str) -> None:
+    """Validate the NLU training data payload of the request body."""
     try:
         RasaYAMLReader().validate(yaml_text)
     except Exception as e:
@@ -1578,6 +1582,38 @@ def _validate_yaml_training_payload(yaml_text: Text) -> None:
         )
 
 
+def _validate_flows_payload(yaml_text: str) -> None:
+    """Validate the flows payload of the request body."""
+    try:
+        YAMLFlowsReader().read_from_string(yaml_text)
+    except (YamlException, RasaException) as exc:
+        # if the payload does not contain any flows, we can ignore the error
+        if (
+            hasattr(exc, "validation_errors")
+            and exc.validation_errors is not None
+            and any(
+                [
+                    "'flows' is a required property" in error.message
+                    for error in exc.validation_errors
+                ]
+            )
+        ):
+            return None
+
+        raise ErrorResponse(
+            HTTPStatus.BAD_REQUEST,
+            "BadRequest",
+            f"The request body does not contain valid YAML. Error: {exc}",
+            help_url=DOCS_URL_FLOWS,
+        )
+
+
+def _validate_yaml_training_payload(yaml_text: str) -> None:
+    """Validate the YAML training payload of the request body."""
+    _validate_nlu_training_data_payload(yaml_text)
+    _validate_flows_payload(yaml_text)
+
+
 def _extract_core_additional_arguments(request: Request) -> Dict[Text, Any]:
     return {
         "augmentation_factor": rasa.utils.endpoints.int_arg(request, "augmentation", 50)

rasa/shared/constants.py

@@ -19,6 +19,7 @@ DOCS_URL_GRAPH_COMPONENTS = DOCS_URL_CONCEPTS + "/components/custom-graph-compon
 DOCS_URL_GRAPH_RECIPE = DOCS_URL_CONCEPTS + "/components/graph-recipe"
 DOCS_URL_CATEGORICAL_SLOTS = DOCS_URL_CONCEPTS + "/domain#categorical-slot"
 DOCS_URL_DOMAIN = DOCS_URL_CONCEPTS + "/domain"
+DOCS_URL_FLOWS = DOCS_URL_CONCEPTS + "/flows"
 
 # Docs URLs for NLU-based assistants
 DOCS_URL_TRAINING_DATA = DOCS_URL_NLU_BASED + "/training-data-format"
@@ -101,28 +102,16 @@ ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 
 CONFIG_MANDATORY_COMMON_KEYS = [ASSISTANT_ID_KEY]
-CONFIG_NAME_KEY = "name"
-CONFIG_POLICIES_KEY = "policies"
-CONFIG_PIPELINE_KEY = "pipeline"
-CONFIG_LANGUAGE_KEY = "language"
-CONFIG_RECIPE_KEY = "recipe"
-CONFIG_LLM_KEY = "llm"
-CONFIG_MODEL_NAME_KEY = "model_name"
-CONFIG_TRAIN_SCHEMA = "train_schema"
-CONFIG_PREDICT_SCHEMA = "predict_schema"
-CONFIG_AUTOCONFIGURABLE_KEYS_CORE = [CONFIG_POLICIES_KEY]
-CONFIG_AUTOCONFIGURABLE_KEYS_NLU = [CONFIG_PIPELINE_KEY]
+CONFIG_AUTOCONFIGURABLE_KEYS_CORE = ["policies"]
+CONFIG_AUTOCONFIGURABLE_KEYS_NLU = ["pipeline"]
 CONFIG_AUTOCONFIGURABLE_KEYS = (
     CONFIG_AUTOCONFIGURABLE_KEYS_CORE + CONFIG_AUTOCONFIGURABLE_KEYS_NLU
 )
-CONFIG_KEYS_CORE = [CONFIG_POLICIES_KEY] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_KEYS_NLU = [
-    CONFIG_LANGUAGE_KEY,
-    CONFIG_PIPELINE_KEY,
-] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_KEYS_CORE = ["policies"] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_KEYS_NLU = ["language", "pipeline"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_KEYS = CONFIG_KEYS_CORE + CONFIG_KEYS_NLU
 CONFIG_MANDATORY_KEYS_CORE: List[Text] = [] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_MANDATORY_KEYS_NLU = [CONFIG_LANGUAGE_KEY] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
 
 # Keys related to Forms (in the Domain)

rasa/shared/core/events.py

@@ -2,10 +2,14 @@ import abc
 import copy
 import json
 import logging
+import structlog
 import re
+from abc import ABC
+
+import jsonpickle
 import time
 import uuid
-from abc import ABC
+from dateutil import parser
 from datetime import datetime
 from typing import (
     List,
@@ -20,14 +24,11 @@ from typing import (
     Tuple,
     TypeVar,
 )
-from typing import Union
-
-import jsonpickle
-import structlog
-from dateutil import parser
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+from typing import Union
+
 from rasa.shared.constants import DOCS_URL_TRAINING_DATA
 from rasa.shared.core.constants import (
     LOOP_NAME,
@@ -61,7 +62,7 @@ from rasa.shared.nlu.constants import (
     ENTITY_ATTRIBUTE_END,
     FULL_RETRIEVAL_INTENT_NAME_KEY,
 )
-from rasa.shared.nlu.constants import PROMPTS
+
 
 if TYPE_CHECKING:
     from typing_extensions import TypedDict
@@ -97,7 +98,6 @@ if TYPE_CHECKING:
             ENTITIES: List[EntityPrediction],
             "message_id": Optional[Text],
             "metadata": Dict,
-            PROMPTS: Dict,
         },
         total=False,
     )

rasa/shared/core/flows/flow.py

@@ -79,7 +79,7 @@ class Flow:
         Returns:
             A Flow object.
         """
-        step_sequence = FlowStepSequence.from_json(data.get("steps"))
+        step_sequence = FlowStepSequence.from_json(flow_id, data.get("steps"))
         nlu_triggers = NLUTriggers.from_json(data.get("nlu_trigger"))
 
         if file_path and isinstance(file_path, Path):
@@ -185,13 +185,13 @@ class Flow:
             return None
 
         if step_id == START_STEP:
-            return StartFlowStep(self.first_step_in_flow().id)
+            return StartFlowStep(self.id, self.first_step_in_flow().id)
 
         if step_id == END_STEP:
-            return EndFlowStep()
+            return EndFlowStep(self.id)
 
         if step_id.startswith(CONTINUE_STEP_PREFIX):
-            return ContinueFlowStep(step_id[len(CONTINUE_STEP_PREFIX) :])
+            return ContinueFlowStep(self.id, step_id[len(CONTINUE_STEP_PREFIX) :])
 
         for step in self.steps_with_calls_resolved:
             if step.id == step_id:

rasa/shared/core/flows/flow_step.py

@@ -20,10 +20,11 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def step_from_json(data: Dict[Text, Any]) -> FlowStep:
+def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
     """Create a specific FlowStep from serialized data.
 
     Args:
+        flow_id: The id of the flow that contains the step.
         data: data for a specific FlowStep object in a serialized data format.
 
     Returns:
@@ -39,17 +40,17 @@ def step_from_json(data: Dict[Text, Any]) -> FlowStep:
     )
 
     if "action" in data:
-        return ActionFlowStep.from_json(data)
+        return ActionFlowStep.from_json(flow_id, data)
     if "collect" in data:
-        return CollectInformationFlowStep.from_json(data)
+        return CollectInformationFlowStep.from_json(flow_id, data)
     if "link" in data:
-        return LinkFlowStep.from_json(data)
+        return LinkFlowStep.from_json(flow_id, data)
     if "call" in data:
-        return CallFlowStep.from_json(data)
+        return CallFlowStep.from_json(flow_id, data)
     if "set_slots" in data:
-        return SetSlotsFlowStep.from_json(data)
+        return SetSlotsFlowStep.from_json(flow_id, data)
     if "noop" in data:
-        return NoOperationFlowStep.from_json(data)
+        return NoOperationFlowStep.from_json(flow_id, data)
     raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
 
 
@@ -67,12 +68,15 @@ class FlowStep:
     """Additional, unstructured information about this flow step."""
     next: FlowStepLinks
     """The next steps of the flow step."""
+    flow_id: Text
+    """The id of the flow that contains the step."""
 
     @classmethod
-    def from_json(cls, data: Dict[Text, Any]) -> FlowStep:
+    def from_json(cls, flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
         """Create a FlowStep object from data in a serialized format.
 
         Args:
+            flow_id: The id of the flow that contains the step.
             data: The data for a FlowStep object in a serialized format.
 
         Returns:
@@ -87,7 +91,8 @@ class FlowStep:
             custom_id=data.get("id"),
             description=data.get("description"),
             metadata=data.get("metadata", {}),
-            next=FlowStepLinks.from_json(data.get("next", [])),
+            next=FlowStepLinks.from_json(flow_id, data.get("next", [])),
+            flow_id=flow_id,
         )
 
     def does_allow_for_next_step(self) -> bool:
@@ -125,7 +130,7 @@ class FlowStep:
     @property
     def default_id(self) -> str:
         """Returns the default id of the flow step."""
-        return f"{self.idx}_{self.default_id_postfix}"
+        return f"{self.flow_id}_{self.idx}_{self.default_id_postfix}"
 
     @property
     def default_id_postfix(self) -> str: