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

rasa/shared/core/constants.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
+
 from enum import Enum
 
 import rasa.shared.constants as constants
 
-
 DEFAULT_CATEGORICAL_SLOT_VALUE = "__other__"
 
 USER_INTENT_RESTART = "restart"
@@ -13,6 +13,7 @@ USER_INTENT_SESSION_START = "session_start"
 USER_INTENT_SESSION_END = "session_end"
 USER_INTENT_SILENCE_TIMEOUT = "silence_timeout"
 SESSION_START_METADATA_SLOT = "session_started_metadata"
+LANGUAGE_SLOT = "language"
 
 DEFAULT_INTENTS = [
     USER_INTENT_RESTART,
@@ -51,6 +52,11 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
+ACTION_BLOCK_DIGRESSION = "action_block_digression"
+ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
+
+ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
+ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
 
 
 DEFAULT_ACTION_NAMES = [
@@ -78,6 +84,8 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -134,7 +142,11 @@ DEFAULT_SLOT_NAMES = {
 
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
-MAPPING_TYPE = "type"
+KEY_MAPPING_TYPE = "type"
+KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
+KEY_ACTION = "action"
+KEY_RUN_ACTION_EVERY_TURN = "run_action_every_turn"
+KEY_COEXISTENCE_SYSTEM = "coexistence_system"
 
 
 class SlotMappingType(Enum):
@@ -145,7 +157,7 @@ class SlotMappingType(Enum):
     FROM_TRIGGER_INTENT = "from_trigger_intent"
     FROM_TEXT = "from_text"
     FROM_LLM = "from_llm"
-    CUSTOM = "custom"
+    CONTROLLED = "controlled"
 
     def __str__(self) -> str:
         """Returns the string representation that should be used in config files."""
@@ -153,7 +165,21 @@ class SlotMappingType(Enum):
 
     def is_predefined_type(self) -> bool:
         """Returns True if the mapping type is NLU-predefined."""
-        return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
+        return not (
+            self == SlotMappingType.CONTROLLED or self == SlotMappingType.FROM_LLM
+        )
+
+
+class SetSlotExtractor(Enum):
+    """The extractors that can set a slot."""
+
+    LLM = "LLM"
+    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
+    NLU = "NLU"
+    CUSTOM = "CUSTOM"
+
+    def __str__(self) -> str:
+        return self.value
 
 
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
@@ -178,3 +204,7 @@ POLICY_NAME_RULE = "RulePolicy"
 CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
+
+# digression constants
+KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
+KEY_BLOCK_DIGRESSIONS = "block_digressions"

rasa/shared/core/conversation.py

@@ -1,8 +1,7 @@
-from typing import Dict, List, Text, Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, List, Text
 
 import rasa.shared.core.events
 
-
 if TYPE_CHECKING:
     from rasa.shared.core.events import Event
 

rasa/shared/core/domain.py

@@ -46,14 +46,13 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
-    ACTIVE_LOOP,
+    KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_CONDITIONS,
-    MAPPING_TYPE,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
 from rasa.shared.core.events import SlotSet, UserUttered
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
@@ -119,6 +118,7 @@ RESPONSE_KEYS_TO_INTERPOLATE = [
     KEY_RESPONSES_BUTTONS,
     KEY_RESPONSES_ATTACHMENT,
     KEY_RESPONSES_QUICK_REPLIES,
+    KEY_TRANSLATION,
 ]
 
 ALL_DOMAIN_KEYS = [
@@ -290,8 +290,6 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
-        if domain_slots:
-            rasa.shared.core.slot_mappings.validate_slot_mappings(domain_slots)
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)
@@ -596,7 +594,7 @@ class Domain:
                     ),
                 )
                 slot_dict[slot_name][SLOT_MAPPINGS] = [
-                    {MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
+                    {KEY_MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
                 ]
 
             slot = slot_class(slot_name, **slot_dict[slot_name])
@@ -1569,21 +1567,18 @@ class Domain:
                 matching_entities = []
 
                 for mapping in slot.mappings:
-                    mapping_conditions = mapping.get(MAPPING_CONDITIONS)
-                    if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY) or (
+                    mapping_conditions = mapping.conditions
+                    if mapping.type != SlotMappingType.FROM_ENTITY or (
                         mapping_conditions
-                        and mapping_conditions[0].get(ACTIVE_LOOP) is not None
+                        and mapping_conditions[0].active_loop is not None
                     ):
                         continue
 
                     for entity in entities:
                         if (
-                            entity.get(ENTITY_ATTRIBUTE_TYPE)
-                            == mapping.get(ENTITY_ATTRIBUTE_TYPE)
-                            and entity.get(ENTITY_ATTRIBUTE_ROLE)
-                            == mapping.get(ENTITY_ATTRIBUTE_ROLE)
-                            and entity.get(ENTITY_ATTRIBUTE_GROUP)
-                            == mapping.get(ENTITY_ATTRIBUTE_GROUP)
+                            entity.get(ENTITY_ATTRIBUTE_TYPE) == mapping.entity
+                            and entity.get(ENTITY_ATTRIBUTE_ROLE) == mapping.role
+                            and entity.get(ENTITY_ATTRIBUTE_GROUP) == mapping.group
                         ):
                             matching_entities.append(entity.get("value"))
 
@@ -2015,19 +2010,19 @@ class Domain:
             is the total number of mappings which have conditions attached.
         """
         total_mappings = 0
-        custom_mappings = 0
+        controlled_mappings = 0
         conditional_mappings = 0
 
         for slot in self.slots:
             total_mappings += len(slot.mappings)
             for mapping in slot.mappings:
-                if mapping[MAPPING_TYPE] == str(SlotMappingType.CUSTOM):
-                    custom_mappings += 1
+                if mapping.type == SlotMappingType.CONTROLLED:
+                    controlled_mappings += 1
 
-                if MAPPING_CONDITIONS in mapping:
+                if mapping.conditions:
                     conditional_mappings += 1
 
-        return (total_mappings, custom_mappings, conditional_mappings)
+        return total_mappings, controlled_mappings, conditional_mappings
 
     def does_custom_action_explicitly_need_domain(self, action_name: Text) -> bool:
         """Assert if action has explicitly stated that it needs domain.
@@ -2112,6 +2107,10 @@ class Domain:
 
         return read_yaml(raw_yaml_content, expand_env_vars=cls.expand_env_vars)
 
+    def remove_builtin_slots(self) -> None:
+        """Remove all builtin slots from the domain."""
+        self.slots = [slot for slot in self.slots if not slot.is_builtin]
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],

rasa/shared/core/events.py

@@ -2,68 +2,69 @@ import abc
 import copy
 import json
 import logging
-import structlog
 import re
-from abc import ABC
-
-import jsonpickle
 import time
 import uuid
-from dateutil import parser
+from abc import ABC
 from datetime import datetime
 from typing import (
-    List,
-    Dict,
-    Text,
-    Any,
-    Type,
-    Optional,
     TYPE_CHECKING,
+    Any,
+    Dict,
     Iterable,
-    cast,
+    List,
+    Optional,
+    Text,
     Tuple,
+    Type,
     TypeVar,
+    Union,
+    cast,
 )
 
+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,
-    EXTERNAL_MESSAGE_PREFIX,
+    ACTION_LISTEN_NAME,
+    ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
+    ACTION_METADATA_EXECUTION_SUCCESS,
     ACTION_NAME_SENDER_ID_CONNECTOR_STR,
+    ACTION_SESSION_START_NAME,
+    ENTITY_LABEL_SEPARATOR,
+    EXTERNAL_MESSAGE_PREFIX,
     IS_EXTERNAL,
-    USE_TEXT_FOR_FEATURIZATION,
     LOOP_INTERRUPTED,
-    ENTITY_LABEL_SEPARATOR,
-    ACTION_SESSION_START_NAME,
-    ACTION_LISTEN_NAME,
+    LOOP_NAME,
+    USE_TEXT_FOR_FEATURIZATION,
 )
 from rasa.shared.exceptions import UnsupportedFeatureException
 from rasa.shared.nlu.constants import (
-    ENTITY_ATTRIBUTE_TYPE,
-    INTENT,
-    TEXT,
-    ENTITIES,
-    COMMANDS,
-    ENTITY_ATTRIBUTE_VALUE,
-    ACTION_TEXT,
     ACTION_NAME,
-    INTENT_NAME_KEY,
-    ENTITY_ATTRIBUTE_ROLE,
-    ENTITY_ATTRIBUTE_GROUP,
-    PREDICTED_CONFIDENCE_KEY,
-    INTENT_RANKING_KEY,
-    ENTITY_ATTRIBUTE_TEXT,
-    ENTITY_ATTRIBUTE_START,
+    ACTION_TEXT,
+    COMMANDS,
+    ENTITIES,
     ENTITY_ATTRIBUTE_CONFIDENCE,
     ENTITY_ATTRIBUTE_END,
+    ENTITY_ATTRIBUTE_GROUP,
+    ENTITY_ATTRIBUTE_ROLE,
+    ENTITY_ATTRIBUTE_START,
+    ENTITY_ATTRIBUTE_TEXT,
+    ENTITY_ATTRIBUTE_TYPE,
+    ENTITY_ATTRIBUTE_VALUE,
     FULL_RETRIEVAL_INTENT_NAME_KEY,
+    INTENT,
+    INTENT_NAME_KEY,
+    INTENT_RANKING_KEY,
+    PREDICTED_CONFIDENCE_KEY,
+    PROMPTS,
+    TEXT,
 )
 
-
 if TYPE_CHECKING:
     from typing_extensions import TypedDict
 
@@ -98,6 +99,7 @@ if TYPE_CHECKING:
             ENTITIES: List[EntityPrediction],
             "message_id": Optional[Text],
             "metadata": Dict,
+            PROMPTS: Dict,
         },
         total=False,
     )
@@ -147,8 +149,8 @@ def format_message(
         Message with entities annotated inline, e.g.
         `I am from [Berlin]{`"`entity`"`: `"`city`"`}`.
     """
-    from rasa.shared.nlu.training_data.formats.readerwriter import TrainingDataWriter
     from rasa.shared.nlu.training_data import entities_parser
+    from rasa.shared.nlu.training_data.formats.readerwriter import TrainingDataWriter
 
     message_from_md = entities_parser.parse_training_example(text, intent)
     deserialised_entities = deserialise_entities(entities)
@@ -1030,6 +1032,7 @@ class SlotSet(Event):
         value: Optional[Any] = None,
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1041,6 +1044,7 @@ class SlotSet(Event):
         """
         self.key = key
         self.value = value
+        self._filled_by = filled_by
         super().__init__(timestamp, metadata)
 
     def __repr__(self) -> Text:
@@ -1058,6 +1062,14 @@ class SlotSet(Event):
 
         return (self.key, self.value) == (other.key, other.value)
 
+    @property
+    def filled_by(self) -> Optional[str]:
+        return self._filled_by
+
+    @filled_by.setter
+    def filled_by(self, value: str) -> None:
+        self._filled_by = value
+
     def as_story_string(self) -> Text:
         """Returns text representation of event."""
         props = json.dumps({self.key: self.value}, ensure_ascii=False)
@@ -1079,7 +1091,7 @@ class SlotSet(Event):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"name": self.key, "value": self.value})
+        d.update({"name": self.key, "value": self.value, "filled_by": self.filled_by})
         return d
 
     @classmethod
@@ -1090,13 +1102,14 @@ class SlotSet(Event):
                 parameters.get("value"),
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
+                filled_by=parameters.get("filled_by"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")
 
     def apply_to(self, tracker: "DialogueStateTracker") -> None:
         """Applies event to current conversation state."""
-        tracker._set_slot(self.key, self.value)
+        tracker._set_slot(self.key, self.value, self.filled_by)
 
 
 class Restarted(AlwaysEqualEventMixin):
@@ -1704,7 +1717,15 @@ class ActionExecuted(Event):
         super().__init__(timestamp, metadata)
 
     def __members__(self) -> Tuple[Optional[Text], Optional[Text], Text]:
-        meta_no_nones = {k: v for k, v in self.metadata.items() if v is not None}
+        items_to_ignore = [
+            ACTION_METADATA_EXECUTION_SUCCESS,
+            ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
+        ]
+        meta_no_nones = {
+            k: v
+            for k, v in self.metadata.items()
+            if v is not None and k not in items_to_ignore
+        }
         return (self.action_name, self.action_text, jsonpickle.encode(meta_no_nones))
 
     def __repr__(self) -> Text:

rasa/shared/core/flows/__init__.py

@@ -2,6 +2,5 @@ from .flow import Flow
 from .flow_step import FlowStep
 from .flows_list import FlowsList
 
-
 # to make ruff happy and use the imported names
 all_classes = [FlowStep, Flow, FlowsList]

rasa/shared/core/flows/constants.py

@@ -0,0 +1,11 @@
+KEY_ID = "id"
+KEY_STEPS = "steps"
+KEY_NAME = "name"
+KEY_DESCRIPTION = "description"
+KEY_IF = "if"
+KEY_ALWAYS_INCLUDE_IN_PROMPT = "always_include_in_prompt"
+KEY_NLU_TRIGGER = "nlu_trigger"
+KEY_FILE_PATH = "file_path"
+KEY_PERSISTED_SLOTS = "persisted_slots"
+KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
+KEY_TRANSLATION = "translation"

rasa/shared/core/flows/flow.py

@@ -4,40 +4,70 @@ import copy
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
-from typing import Text, Optional, Dict, Any, List, Set, Union
+from typing import Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
+from pydantic import BaseModel
 from pypred import Predicate
 
 import rasa.shared.utils.io
+from rasa.engine.language import Language
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.flows.flow_path import PathNode, FlowPath, FlowPathsList
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
+from rasa.shared.core.flows.constants import (
+    KEY_ALWAYS_INCLUDE_IN_PROMPT,
+    KEY_DESCRIPTION,
+    KEY_FILE_PATH,
+    KEY_ID,
+    KEY_IF,
+    KEY_NAME,
+    KEY_NLU_TRIGGER,
+    KEY_PERSISTED_SLOTS,
+    KEY_RUN_PATTERN_COMPLETED,
+    KEY_STEPS,
+    KEY_TRANSLATION,
+)
+from rasa.shared.core.flows.flow_path import FlowPath, FlowPathsList, PathNode
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flow_step_links import (
+    ElseFlowStepLink,
     FlowStepLink,
-    StaticFlowStepLink,
     IfFlowStepLink,
-    ElseFlowStepLink,
+    StaticFlowStepLink,
 )
 from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
 from rasa.shared.core.flows.nlu_trigger import NLUTriggers
 from rasa.shared.core.flows.steps import (
+    ActionFlowStep,
     CollectInformationFlowStep,
     EndFlowStep,
     StartFlowStep,
-    ActionFlowStep,
 )
 from rasa.shared.core.flows.steps.constants import (
     CONTINUE_STEP_PREFIX,
-    START_STEP,
     END_STEP,
+    START_STEP,
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
+from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
 
 
+class FlowLanguageTranslation(BaseModel):
+    """Represents the translation of the flow properties in a specific language."""
+
+    name: str
+    """The human-readable name of the flow."""
+
+    class Config:
+        extra = "ignore"
+
+
 @dataclass
 class Flow:
     """Represents the configuration of a flow."""
@@ -48,6 +78,8 @@ class Flow:
     """The human-readable name of the flow."""
     description: Optional[Text] = None
     """The description of the flow."""
+    translation: Dict[Text, FlowLanguageTranslation] = field(default_factory=dict)
+    """The translation of the flow properties in different languages."""
     guard_condition: Optional[Text] = None
     """The condition that needs to be fulfilled for the flow to be startable."""
     step_sequence: FlowStepSequence = field(default_factory=FlowStepSequence.empty)
@@ -62,6 +94,12 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
+    ask_confirm_digressions: List[str] = field(default_factory=list)
+    """The flow ids for which the assistant should ask for confirmation."""
+    block_digressions: List[str] = field(default_factory=list)
+    """The flow ids that the assistant should block from digressing to."""
+    run_pattern_completed: bool = True
+    """Whether the pattern_completed flow should be run after the flow ends."""
 
     @staticmethod
     def from_json(
@@ -79,6 +117,8 @@ class Flow:
         Returns:
             A Flow object.
         """
+        from rasa.shared.core.flows.utils import extract_translations
+
         step_sequence = FlowStepSequence.from_json(flow_id, data.get("steps"))
         nlu_triggers = NLUTriggers.from_json(data.get("nlu_trigger"))
 
@@ -87,17 +127,25 @@ class Flow:
 
         return Flow(
             id=flow_id,
-            custom_name=data.get("name"),
-            description=data.get("description"),
-            always_include_in_prompt=data.get("always_include_in_prompt"),
-            # str or bool are permitted in the flow schema but internally we want a str
-            guard_condition=str(data["if"]) if "if" in data else None,
+            custom_name=data.get(KEY_NAME),
+            description=data.get(KEY_DESCRIPTION),
+            always_include_in_prompt=data.get(KEY_ALWAYS_INCLUDE_IN_PROMPT),
+            # str or bool are permitted in the flow schema, but internally we want a str
+            guard_condition=str(data[KEY_IF]) if KEY_IF in data else None,
             step_sequence=Flow.resolve_default_ids(step_sequence),
             nlu_triggers=nlu_triggers,
             # If we are reading the flows in after training the file_path is part of
             # data. When the model is trained, take the provided file_path.
-            file_path=data.get("file_path") if "file_path" in data else file_path,
-            persisted_slots=data.get("persisted_slots", []),
+            file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
+            persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
+            run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
+            translation=extract_translations(
+                translation_data=data.get(KEY_TRANSLATION, {})
+            ),
         )
 
     def get_full_name(self) -> str:
@@ -155,29 +203,62 @@ class Flow:
             The Flow object as serialized data.
         """
         data: Dict[Text, Any] = {
-            "id": self.id,
-            "steps": self.step_sequence.as_json(),
+            KEY_ID: self.id,
+            KEY_STEPS: self.step_sequence.as_json(),
         }
         if self.custom_name is not None:
-            data["name"] = self.custom_name
+            data[KEY_NAME] = self.custom_name
         if self.description is not None:
-            data["description"] = self.description
+            data[KEY_DESCRIPTION] = self.description
         if self.guard_condition is not None:
-            data["if"] = self.guard_condition
+            data[KEY_IF] = self.guard_condition
         if self.always_include_in_prompt is not None:
-            data["always_include_in_prompt"] = self.always_include_in_prompt
+            data[KEY_ALWAYS_INCLUDE_IN_PROMPT] = self.always_include_in_prompt
         if self.nlu_triggers:
-            data["nlu_trigger"] = self.nlu_triggers.as_json()
+            data[KEY_NLU_TRIGGER] = self.nlu_triggers.as_json()
         if self.file_path:
-            data["file_path"] = self.file_path
+            data[KEY_FILE_PATH] = self.file_path
         if self.persisted_slots:
-            data["persisted_slots"] = self.persisted_slots
+            data[KEY_PERSISTED_SLOTS] = self.persisted_slots
+        if self.ask_confirm_digressions:
+            data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
+        if self.block_digressions:
+            data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
+        if self.run_pattern_completed is not None:
+            data["run_pattern_completed"] = self.run_pattern_completed
+        if self.translation:
+            data[KEY_TRANSLATION] = {
+                language_code: translation.dict()
+                for language_code, translation in self.translation.items()
+            }
 
         return data
 
-    def readable_name(self) -> str:
-        """Returns the name of the flow or its id if no name is set."""
-        return self.name or self.id
+    def localized_name(self, language: Optional[Language] = None) -> Optional[Text]:
+        """Returns the language specific flow name or None.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            Flow name in the specified language or None.
+        """
+        language_code = language.code if language else None
+        translation = self.translation.get(language_code)
+        return translation.name if translation else None
+
+    def readable_name(self, language: Optional[Language] = None) -> str:
+        """
+        Returns the flow's name in the specified language if available; otherwise
+        falls back to the flow's name, and finally the flow's ID.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            string: the localized name, the default name, or the flow's ID.
+        """
+        return self.localized_name(language) or self.name or self.id
 
     def step_by_id(self, step_id: Optional[Text]) -> Optional[FlowStep]:
         """Returns the step with the given id."""
@@ -371,7 +452,7 @@ class Flow:
             True if dynamic literals are present, False otherwise.
         """
         from pypred import ast
-        from pypred.tiler import tile, SimplePattern
+        from pypred.tiler import SimplePattern, tile
 
         if not self.guard_condition:
             return False

rasa/shared/core/flows/flow_step.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
 from dataclasses import dataclass
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     Generator,
@@ -10,6 +10,7 @@ from typing import (
     Set,
     Text,
 )
+
 import structlog
 
 from rasa.shared.exceptions import RasaException
@@ -32,11 +33,11 @@ def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
     """
     from rasa.shared.core.flows.steps import (
         ActionFlowStep,
+        CallFlowStep,
         CollectInformationFlowStep,
         LinkFlowStep,
-        SetSlotsFlowStep,
         NoOperationFlowStep,
-        CallFlowStep,
+        SetSlotsFlowStep,
     )
 
     if "action" in data:

rasa/shared/core/flows/flow_step_links.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
 from dataclasses import dataclass
-from typing import List, Union, Dict, Text, Any, Optional, Generator
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Text, Union
 
 from rasa.shared.core.flows.flow_step import FlowStep