rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -18,6 +18,7 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
+from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.stack.frames import (
     ChitChatStackFrame,
     DialogueStackFrame,
@@ -38,8 +39,10 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import (
     ActionExecuted,
@@ -57,6 +60,10 @@ from rasa.shared.providers.embedding._langchain_embedding_client_adapter import
     _LangchainEmbeddingClientAdapter,
 )
 from rasa.shared.providers.llm.llm_client import LLMClient
+from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
+    EmbeddingsHealthCheckMixin,
+)
+from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     AI,
@@ -70,9 +77,9 @@ from rasa.shared.utils.llm import (
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
-    try_instantiate_llm_client,
-    try_instantiate_embedder,
+    resolve_model_client_config,
 )
+from rasa.utils.log_utils import log_llm
 from rasa.utils.ml_utils import (
     extract_ai_response_examples,
     extract_participant_messages_from_transcript,
@@ -81,9 +88,6 @@ from rasa.utils.ml_utils import (
     persist_faiss_vector_store,
     response_for_template,
 )
-from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
-from rasa.utils.log_utils import log_llm
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
@@ -123,6 +127,7 @@ DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
 ).name
 
 INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = "intentless_policy_prompt.jinja2"
+INTENTLESS_CONFIG_FILE_NAME = "config.json"
 
 
 class RasaMLPolicyTrainingException(RasaCoreException):
@@ -372,7 +377,7 @@ def conversation_as_prompt(conversation: Conversation) -> str:
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
-class IntentlessPolicy(Policy):
+class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
     """Policy which uses a language model to generate the next action.
 
     The policy uses the OpenAI API to generate the next action based on the
@@ -429,6 +434,16 @@ class IntentlessPolicy(Policy):
         """Constructs a new Policy object."""
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
+        # Resolve LLM config
+        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
+            self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+        )
+
+        # Resolve embeddings config
+        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        )
+
         self.nlu_abstention_threshold: float = self.config[NLU_ABSTENTION_THRESHOLD]
         self.response_index = responses_docsearch
         self.conversation_samples_index = samples_docsearch
@@ -445,9 +460,16 @@ class IntentlessPolicy(Policy):
         Returns:
         The embedder.
         """
+        # Copy the config so original config is not modified
+        config.copy()
+        # Resolve config and instantiate the embedding client
+        config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        )
         client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        # Wrap the embedding client in the adapter
         return _LangchainEmbeddingClientAdapter(client)
 
     def embeddings_property(self, prop: str) -> Optional[str]:
@@ -488,12 +510,8 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
-        try_instantiate_llm_client(
-            self.config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "intentless_policy.train",
-            "IntentlessPolicy",
-        )
+        # Perform health checks of both LLM and embeddings client configs
+        self._perform_health_checks(self.config, "intentless_policy.train")
 
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()
@@ -540,9 +558,13 @@ class IntentlessPolicy(Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
 
         self.persist()
@@ -558,6 +580,9 @@ class IntentlessPolicy(Policy):
             rasa.shared.utils.io.write_text_file(
                 self.prompt_template, path / INTENTLESS_PROMPT_TEMPLATE_FILE_NAME
             )
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                path / INTENTLESS_CONFIG_FILE_NAME, self.config
+            )
 
     async def predict_action_probabilities(
         self,
@@ -619,9 +644,13 @@ class IntentlessPolicy(Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
             score=score,
         )
 
@@ -645,7 +674,7 @@ class IntentlessPolicy(Policy):
         history: str,
     ) -> Optional[str]:
         """Make the llm call to generate an answer."""
-        llm = llm_factory(self.config[LLM_CONFIG_KEY], DEFAULT_LLM_CONFIG)
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
         inputs = {
             "conversations": conversation_samples,
             "responses": response_examples,
@@ -919,18 +948,10 @@ class IntentlessPolicy(Policy):
         **kwargs: Any,
     ) -> "IntentlessPolicy":
         """Loads a trained policy (see parent class for full docstring)."""
-        try_instantiate_llm_client(
-            config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "intentless_policy.load",
-            IntentlessPolicy.__name__,
-        )
-        try_instantiate_embedder(
-            config.get(EMBEDDINGS_CONFIG_KEY),
-            DEFAULT_EMBEDDINGS_CONFIG,
-            "intentless_policy.load",
-            IntentlessPolicy.__name__,
-        )
+
+        # Perform health checks of both LLM and embeddings client configs
+        cls._perform_health_checks(config, "intentless_policy.load")
+
         responses_docsearch = None
         samples_docsearch = None
         prompt_template = None
@@ -951,11 +972,11 @@ class IntentlessPolicy(Policy):
                 prompt_template = rasa.shared.utils.io.read_file(
                     path / INTENTLESS_PROMPT_TEMPLATE_FILE_NAME
                 )
-
         except (ValueError, FileNotFoundError, FileIOException) as e:
             structlogger.warning(
                 "intentless_policy.load.failed", error=e, resource_name=resource.name
             )
+
         return cls(
             config,
             model_storage,
@@ -968,9 +989,43 @@ class IntentlessPolicy(Policy):
 
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
-        """Add a fingerprint of the knowledge base for the graph."""
+        """Add a fingerprint of intentless policy for the graph."""
         prompt_template = get_prompt_template(
             config.get(PROMPT_CONFIG_KEY),
             DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         )
-        return deep_container_fingerprint(prompt_template)
+
+        llm_config = resolve_model_client_config(
+            config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+        )
+        embedding_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        )
+
+        return deep_container_fingerprint(
+            [prompt_template, llm_config, embedding_config]
+        )
+
+    @classmethod
+    def _perform_health_checks(
+        cls, config: Dict[Text, Any], log_source_method: str
+    ) -> None:
+        # Perform health check of the LLM client config
+        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
+        cls.perform_llm_health_check(
+            llm_config,
+            DEFAULT_LLM_CONFIG,
+            log_source_method,
+            IntentlessPolicy.__name__,
+        )
+
+        # Perform health check of the embeddings client config
+        embeddings_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY, {})
+        )
+        cls.perform_embeddings_health_check(
+            embeddings_config,
+            DEFAULT_EMBEDDINGS_CONFIG,
+            log_source_method,
+            IntentlessPolicy.__name__,
+        )

rasa/core/processor.py

@@ -46,12 +46,15 @@ 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_LISTEN_NAME,
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
     ACTION_EXTRACT_SLOTS,
+    USER_INTENT_SILENCE_TIMEOUT,
 )
 from rasa.shared.core.events import (
     ActionExecutionRejected,
@@ -789,6 +792,28 @@ class MessageProcessor:
         )
 
         self._check_for_unseen_features(parse_data)
+        # resetting timeouts variables whenever something that is not a timeout occurs
+        if (
+            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
+            != USER_INTENT_SILENCE_TIMEOUT
+            and tracker
+        ):
+            if (
+                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
+                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
+            ):
+                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
+            if (
+                SLOT_SILENCE_TIMEOUT in tracker.slots
+                and tracker.slots[SLOT_SILENCE_TIMEOUT].value
+                != tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value
+            ):
+                tracker.update(
+                    SlotSet(
+                        SLOT_SILENCE_TIMEOUT,
+                        tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value,
+                    )
+                )
 
         return parse_data
 

rasa/core/run.py

@@ -19,6 +19,7 @@ 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
@@ -32,8 +33,8 @@ 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.persistor import StorageType
 from rasa.core.utils import AvailableEndpoints
-from rasa.nlu.persistor import StorageType
 from rasa.plugin import plugin_manager
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_config_file
@@ -50,7 +51,6 @@ def create_http_input_channels(
         all_credentials = read_config_file(credentials_file)
     else:
         all_credentials = {}
-
     if channel:
         if len(all_credentials) > 1:
             logger.info(
@@ -224,6 +224,8 @@ def serve_application(
     syslog_protocol: Optional[Text] = None,
     request_timeout: Optional[int] = None,
     server_listeners: Optional[List[Tuple[Callable, Text]]] = None,
+    inspect: Optional[bool] = False,
+    voice: Optional[bool] = False,
 ) -> None:
     """Run the API entrypoint."""
     if not channel and not credentials:
@@ -231,6 +233,13 @@ def serve_application(
 
     input_channels = create_http_input_channels(channel, credentials)
 
+    if inspect:
+        logger.info("Starting development inspector.")
+        input_channels = [DevelopmentInspectProxy(ic, voice) for ic in input_channels]
+
+        # the inspector needs the api to retrieve slots and flows
+        enable_api = True
+
     app = configure_app(
         input_channels,
         cors,
@@ -311,6 +320,7 @@ async def load_agent_on_start(
         endpoints=endpoints,
         loop=loop,
     )
+
     logger.info("Rasa server is up and running.")
     return app.ctx.agent
 

rasa/core/secrets_manager/constants.py

@@ -23,6 +23,7 @@ VAULT_TRANSIT_MOUNT_POINT_ENV_NAME = "VAULT_TRANSIT_MOUNT_POINT"
 VAULT_NAMESPACE_ENV_NAME = "VAULT_NAMESPACE"
 VAULT_DEFAULT_RASA_SECRETS_PATH = "rasa-secrets"
 VAULT_SECRET_MANAGER_NAME = "vault"
+VAULT_MOUNT_POINT_ENV_NAME = "VAULT_MOUNT_POINT"
 
 
 VAULT_ENDPOINT_URL_LABEL = "url"
@@ -30,3 +31,6 @@ VAULT_ENDPOINT_TOKEN_LABEL = "token"
 VAULT_ENDPOINT_SECRETS_PATH_LABEL = "secrets_path"
 VAULT_ENDPOINT_TRANSIT_MOUNT_POINT_LABEL = "transit_mount_point"
 VAULT_ENDPOINT_NAMESPACE_LABEL = "namespace"
+VAULT_ENDPOINT_MOUNT_POINT_LABEL = "mount_point"
+
+VAULT_MOUNT_POINT_DEFAULT_VALUE = "secret"

rasa/core/secrets_manager/factory.py

@@ -7,9 +7,11 @@ 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,
+    VAULT_ENDPOINT_MOUNT_POINT_LABEL,
     VAULT_ENDPOINT_NAMESPACE_LABEL,
     VAULT_ENDPOINT_SECRETS_PATH_LABEL,
     VAULT_ENDPOINT_TRANSIT_MOUNT_POINT_LABEL,
+    VAULT_MOUNT_POINT_ENV_NAME,
     VAULT_NAMESPACE_ENV_NAME,
     VAULT_RASA_SECRETS_PATH_ENV_NAME,
     VAULT_SECRET_MANAGER_NAME,
@@ -48,6 +50,7 @@ def create(config: SecretManagerConfig) -> Optional[SecretsManager]:
             transit_mount_point=vault_config.transit_mount_point,
             secrets_path=vault_config.secrets_path,
             namespace=vault_config.namespace,
+            mount_point=vault_config.mount_point,
         )
 
     return secret_manager
@@ -79,6 +82,7 @@ def read_vault_endpoint_config(
         )
         secrets_path = endpoint_config.kwargs.get(VAULT_ENDPOINT_SECRETS_PATH_LABEL)
         namespace = endpoint_config.kwargs.get(VAULT_ENDPOINT_NAMESPACE_LABEL)
+        mount_point = endpoint_config.kwargs.get(VAULT_ENDPOINT_MOUNT_POINT_LABEL)
 
         return VaultSecretManagerNonStrictConfig(
             url=url,
@@ -86,6 +90,7 @@ def read_vault_endpoint_config(
             transit_mount_point=transit_mount_point,
             secrets_path=secrets_path or VAULT_DEFAULT_RASA_SECRETS_PATH,
             namespace=namespace,
+            mount_point=mount_point,
         )
 
     return None
@@ -102,6 +107,7 @@ def read_vault_env_vars() -> VaultSecretManagerNonStrictConfig:
     transit_mount_point = os.getenv(VAULT_TRANSIT_MOUNT_POINT_ENV_NAME)
     secrets_path = os.getenv(VAULT_RASA_SECRETS_PATH_ENV_NAME)
     namespace = os.getenv(VAULT_NAMESPACE_ENV_NAME)
+    mount_point = os.getenv(VAULT_MOUNT_POINT_ENV_NAME)
 
     return VaultSecretManagerNonStrictConfig(
         url=url,
@@ -109,6 +115,7 @@ def read_vault_env_vars() -> VaultSecretManagerNonStrictConfig:
         transit_mount_point=transit_mount_point,
         secrets_path=secrets_path,
         namespace=namespace,
+        mount_point=mount_point,
     )
 
 
@@ -149,6 +156,7 @@ def read_vault_config(
         f"{VAULT_RASA_SECRETS_PATH_ENV_NAME} = {env_config.secrets_path}, "
         f"{VAULT_TRANSIT_MOUNT_POINT_ENV_NAME} = {env_config.transit_mount_point}. "
         f"{VAULT_NAMESPACE_ENV_NAME} = {env_config.namespace}. "
+        f"{VAULT_MOUNT_POINT_ENV_NAME} = {env_config.mount_point}. "
     )
 
 

rasa/core/secrets_manager/vault.py

@@ -15,6 +15,7 @@ from rasa.utils.endpoints import EndpointConfig
 from rasa.core.secrets_manager.constants import (
     TRACKER_STORE_ENDPOINT_TYPE,
     TRANSIT_KEY_FOR_ENCRYPTION_LABEL,
+    VAULT_MOUNT_POINT_DEFAULT_VALUE,
     VAULT_SECRET_MANAGER_NAME,
 )
 from rasa.core.secrets_manager.endpoints import (
@@ -181,6 +182,7 @@ class VaultSecretsManager(SecretsManager):
         secrets_path: Text,
         transit_mount_point: Optional[Text] = None,
         namespace: Optional[Text] = None,
+        mount_point: Optional[Text] = None,
     ):
         """Initialise the VaultSecretsManager.
 
@@ -190,11 +192,13 @@ class VaultSecretsManager(SecretsManager):
             secrets_path: The path to the secrets in the vault server.
             transit_mount_point: The mount point of the transit engine.
             namespace: The namespace in which secrets reside in.
+            mount_point: The mount point of the kv engine.
         """
         self.host = host
         self.transit_mount_point = transit_mount_point
         self.token = token
         self.secrets_path = secrets_path
+        self.mount_point = mount_point or VAULT_MOUNT_POINT_DEFAULT_VALUE
         self.namespace = namespace
 
         # Create client
@@ -236,7 +240,7 @@ class VaultSecretsManager(SecretsManager):
         """
         logger.info(f"Loading secrets from vault server at {self.host}.")
         read_response = self.client.secrets.kv.read_secret_version(
-            mount_point="secret", path=self.secrets_path
+            mount_point=self.mount_point, path=self.secrets_path
         )
 
         secrets = read_response["data"]["data"]
@@ -455,6 +459,7 @@ class VaultSecretManagerConfig(SecretManagerConfig):
         secrets_path: Text,
         transit_mount_point: Text = "transit",
         namespace: Optional[Text] = None,
+        mount_point: Optional[Text] = None,
     ) -> None:
         """Initialise the VaultSecretManagerConfig.
 
@@ -471,6 +476,7 @@ class VaultSecretManagerConfig(SecretManagerConfig):
         self.secrets_path = secrets_path
         self.transit_mount_point = transit_mount_point
         self.namespace = namespace
+        self.mount_point = mount_point
 
 
 @dataclass
@@ -486,6 +492,7 @@ class VaultSecretManagerNonStrictConfig:
     secrets_path: Optional[Text]
     transit_mount_point: Optional[Text]
     namespace: Optional[Text] = None
+    mount_point: Optional[Text] = None
 
     def is_empty(self) -> bool:
         """Check if all the values are empty."""
@@ -495,6 +502,7 @@ class VaultSecretManagerNonStrictConfig:
             and (self.secrets_path is None or self.secrets_path == "")
             and (self.transit_mount_point is None or self.transit_mount_point == "")
             and (self.namespace is None or self.namespace == "")
+            and (self.mount_point is None or self.mount_point == "")
         )
 
     def is_valid(self) -> bool:
@@ -516,6 +524,7 @@ class VaultSecretManagerNonStrictConfig:
             and self.secrets_path != ""
             and self._is_optional_value_valid(self.transit_mount_point)
             and self._is_optional_value_valid(self.namespace)
+            and self._is_optional_value_valid(self.mount_point)
         )
 
     @staticmethod
@@ -547,6 +556,7 @@ class VaultSecretManagerNonStrictConfig:
             secrets_path=self.secrets_path or other.secrets_path,
             transit_mount_point=self.transit_mount_point or other.transit_mount_point,
             namespace=self.namespace or other.namespace,
+            mount_point=self.mount_point or other.mount_point,
         )
 
 

rasa/core/training/interactive.py

@@ -20,25 +20,41 @@ from typing import (
     cast,
 )
 
+import numpy as np
+import questionary
+import terminaltables.width_and_alignment
+from aiohttp import ClientError
+from colorclass import Color
+from questionary import Choice, Form, Question
 from sanic import Sanic, response
 from sanic.exceptions import NotFound
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from terminaltables import AsciiTable, SingleTable
-import terminaltables.width_and_alignment
-import numpy as np
-from aiohttp import ClientError
-from colorclass import Color
-import questionary
-from questionary import Choice, Form, Question
 
-from rasa import telemetry
-import rasa.shared.utils.cli
-import rasa.shared.utils.io
 import rasa.cli.utils
+import rasa.core.train
+import rasa.shared.core.events
 import rasa.shared.data
-from rasa.shared.nlu.constants import TEXT, INTENT_NAME_KEY
-from rasa.shared.nlu.training_data.loading import RASA, RASA_YAML
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
+
+# WARNING: This command line UI is using an external library
+# communicating with the shell - these functions are hard to test
+# automatically. If you change anything in here, please make sure to
+# run the interactive learning and check if your part of the "ui"
+# still works.
+import rasa.utils.io as io_utils
+from rasa import telemetry
+from rasa.core import run, utils
+from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
+from rasa.core.utils import AvailableEndpoints
+from rasa.shared.constants import (
+    INTENT_MESSAGE_PREFIX,
+    DEFAULT_SENDER_ID,
+    UTTER_PREFIX,
+    DOCS_URL_NLU_BASED_POLICIES,
+)
 from rasa.shared.core.constants import (
     USER_INTENT_RESTART,
     ACTION_LISTEN_NAME,
@@ -49,9 +65,6 @@ from rasa.shared.core.constants import (
     LOOP_INTERRUPTED,
     ACTION_UNLIKELY_INTENT_NAME,
 )
-from rasa.core import run, utils
-import rasa.core.train
-from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
 from rasa.shared.core.domain import (
     Domain,
     KEY_INTENTS,
@@ -60,7 +73,6 @@ from rasa.shared.core.domain import (
     KEY_ACTIONS,
     KEY_RESPONSES_TEXT,
 )
-import rasa.shared.core.events
 from rasa.shared.core.events import (
     ActionExecuted,
     ActionReverted,
@@ -70,36 +82,23 @@ from rasa.shared.core.events import (
     UserUttered,
     UserUtteranceReverted,
 )
-from rasa.shared.constants import (
-    INTENT_MESSAGE_PREFIX,
-    DEFAULT_SENDER_ID,
-    UTTER_PREFIX,
-    DOCS_URL_NLU_BASED_POLICIES,
-)
+from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.trackers import EventVerbosity, DialogueStateTracker
 from rasa.shared.core.training_data import visualization
 from rasa.shared.core.training_data.visualization import (
     VISUALIZATION_TEMPLATE_PATH,
     visualize_neighborhood,
 )
-from rasa.core.utils import AvailableEndpoints
-from rasa.shared.importers.rasa import TrainingDataImporter
-from rasa.utils.common import update_sanic_log_level
-from rasa.utils.endpoints import EndpointConfig
 from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.importers.rasa import TrainingDataImporter
+from rasa.shared.nlu.constants import TEXT, INTENT_NAME_KEY
 
 # noinspection PyProtectedMember
 from rasa.shared.nlu.training_data import loading
+from rasa.shared.nlu.training_data.loading import RASA, RASA_YAML
 from rasa.shared.nlu.training_data.message import Message
-
-# WARNING: This command line UI is using an external library
-# communicating with the shell - these functions are hard to test
-# automatically. If you change anything in here, please make sure to
-# run the interactive learning and check if your part of the "ui"
-# still works.
-import rasa.utils.io as io_utils
-
-from rasa.shared.core.generator import TrackerWithCachedStates
+from rasa.utils.common import update_sanic_log_level
+from rasa.utils.endpoints import EndpointConfig
 
 logger = logging.getLogger(__name__)