rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc1__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -1,6 +1,5 @@
 import importlib.resources
 import math
-import os
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING, Text, Tuple
 
@@ -19,6 +18,11 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
+from rasa.dialogue_understanding.generator.constants import (
+    TRAINED_MODEL_NAME_CONFIG_KEY,
+    TRAINED_EMBEDDINGS_CONFIG_KEY,
+)
+from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.stack.frames import (
     ChitChatStackFrame,
     DialogueStackFrame,
@@ -32,7 +36,6 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     REQUIRED_SLOTS_KEY,
     EMBEDDINGS_CONFIG_KEY,
-    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -40,8 +43,10 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
+    MODEL_GROUP_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,
@@ -69,12 +74,18 @@ from rasa.shared.utils.llm import (
     combine_custom_and_default_config,
     embedder_factory,
     get_prompt_template,
-    llm_api_health_check,
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
-    try_instantiate_llm_client,
+    resolve_model_client_config,
+)
+from rasa.shared.utils.health_check import (
+    perform_training_time_llm_health_check,
+    perform_training_time_embeddings_health_check,
+    perform_inference_time_llm_health_check,
+    perform_inference_time_embeddings_health_check,
 )
+from rasa.utils.log_utils import log_llm
 from rasa.utils.ml_utils import (
     extract_ai_response_examples,
     extract_participant_messages_from_transcript,
@@ -83,9 +94,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
@@ -125,6 +133,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):
@@ -431,6 +440,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
@@ -447,9 +466,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]:
@@ -490,16 +516,10 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
-        llm_client = try_instantiate_llm_client(
-            self.config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "intentless_policy.train",
-            IntentlessPolicy.__name__,
-        )
-        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
-            llm_api_health_check(
-                llm_client, "intentless_policy.train", IntentlessPolicy.__name__
-            )
+        (
+            self.config[TRAINED_MODEL_NAME_CONFIG_KEY],
+            self.config[TRAINED_EMBEDDINGS_CONFIG_KEY],
+        ) = self._perform_training_time_health_checks()
 
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()
@@ -546,9 +566,11 @@ 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_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_CONFIG_KEY),
         )
 
         self.persist()
@@ -564,6 +586,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,
@@ -625,9 +650,11 @@ 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_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_CONFIG_KEY),
             score=score,
         )
 
@@ -651,7 +678,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,
@@ -928,6 +955,7 @@ class IntentlessPolicy(Policy):
         responses_docsearch = None
         samples_docsearch = None
         prompt_template = None
+        persisted_config = None
         try:
             with model_storage.read_from(resource) as path:
                 responses_docsearch = load_faiss_vector_store(
@@ -945,13 +973,15 @@ class IntentlessPolicy(Policy):
                 prompt_template = rasa.shared.utils.io.read_file(
                     path / INTENTLESS_PROMPT_TEMPLATE_FILE_NAME
                 )
-
+                persisted_config = rasa.shared.utils.io.read_json_file(
+                    path / INTENTLESS_CONFIG_FILE_NAME
+                )
         except (ValueError, FileNotFoundError, FileIOException) as e:
             structlogger.warning(
                 "intentless_policy.load.failed", error=e, resource_name=resource.name
             )
 
-        return cls(
+        policy = cls(
             config,
             model_storage,
             resource,
@@ -961,11 +991,79 @@ class IntentlessPolicy(Policy):
             prompt_template=prompt_template,
         )
 
+        cls._perform_inference_time_health_checks(
+            persisted_config,
+            policy.config.get(LLM_CONFIG_KEY),
+            policy.config.get(EMBEDDINGS_CONFIG_KEY),
+        )
+
+        return 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]
+        )
+
+    def _perform_training_time_health_checks(
+        self,
+    ) -> Tuple[Optional[str], Optional[str]]:
+        train_model_name = perform_training_time_llm_health_check(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "intentless_policy.train",
+            IntentlessPolicy.__name__,
+        )
+        train_embedding_name = perform_training_time_embeddings_health_check(
+            self.config.get(EMBEDDINGS_CONFIG_KEY),
+            DEFAULT_EMBEDDINGS_CONFIG,
+            "intentless_policy.train",
+            IntentlessPolicy.__name__,
+        )
+        return train_model_name, train_embedding_name
+
+    @classmethod
+    def _perform_inference_time_health_checks(
+        cls,
+        persisted_config: Optional[Dict[str, Any]],
+        resolved_llm_config: Optional[Dict[str, Any]],
+        resolved_embeddings_config: Optional[Dict[str, Any]],
+    ) -> None:
+        train_model_name = (
+            persisted_config.get(TRAINED_MODEL_NAME_CONFIG_KEY, None)
+            if persisted_config
+            else None
+        )
+        perform_inference_time_llm_health_check(
+            resolved_llm_config,
+            DEFAULT_LLM_CONFIG,
+            train_model_name,
+            "intentless_policy.load",
+            IntentlessPolicy.__name__,
+        )
+
+        train_embeddings_name = (
+            persisted_config.get(TRAINED_EMBEDDINGS_CONFIG_KEY, None)
+            if persisted_config
+            else None
+        )
+        perform_inference_time_embeddings_health_check(
+            resolved_embeddings_config,
+            DEFAULT_EMBEDDINGS_CONFIG,
+            train_embeddings_name,
+            "intentless_policy.load",
+            IntentlessPolicy.__name__,
+        )

rasa/core/policies/ted_policy.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-import logging
 
-from rasa.engine.recipes.default_recipe import DefaultV1Recipe
+import logging
 from pathlib import Path
 from collections import defaultdict
 import contextlib
+from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
 import numpy as np
 import tensorflow as tf
-from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -49,18 +49,22 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.events import EntitiesAdded, Event
 from rasa.shared.core.domain import Domain
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.nlu.training_data.features import (
+    Features,
+    save_features,
+    load_features,
+)
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.utils import train_utils
-from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
-from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.model_data import (
-    RasaModelData,
-    FeatureSignature,
+from rasa.utils.tensorflow.feature_array import (
     FeatureArray,
-    Data,
+    serialize_nested_feature_arrays,
+    deserialize_nested_feature_arrays,
 )
+from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
+from rasa.utils.tensorflow import rasa_layers
+from rasa.utils.tensorflow.model_data import RasaModelData, FeatureSignature, Data
 from rasa.utils.tensorflow.model_data_utils import convert_to_data_format
 from rasa.utils.tensorflow.constants import (
     LABEL,
@@ -961,22 +965,32 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted
         """
         model_filename = self._metadata_filename()
-        rasa.utils.io.json_pickle(
-            model_path / f"{model_filename}.priority.pkl", self.priority
-        )
-        rasa.utils.io.pickle_dump(
-            model_path / f"{model_filename}.meta.pkl", self.config
+        rasa.shared.utils.io.dump_obj_as_json_to_file(
+            model_path / f"{model_filename}.priority.json", self.priority
         )
-        rasa.utils.io.pickle_dump(
-            model_path / f"{model_filename}.data_example.pkl", self.data_example
+        rasa.shared.utils.io.dump_obj_as_json_to_file(
+            model_path / f"{model_filename}.meta.json", self.config
         )
-        rasa.utils.io.pickle_dump(
-            model_path / f"{model_filename}.fake_features.pkl", self.fake_features
+        # save data example
+        serialize_nested_feature_arrays(
+            self.data_example,
+            str(model_path / f"{model_filename}.data_example.st"),
+            str(model_path / f"{model_filename}.data_example_metadata.json"),
         )
-        rasa.utils.io.pickle_dump(
-            model_path / f"{model_filename}.label_data.pkl",
+        # save label data
+        serialize_nested_feature_arrays(
             dict(self._label_data.data) if self._label_data is not None else {},
+            str(model_path / f"{model_filename}.label_data.st"),
+            str(model_path / f"{model_filename}.label_data_metadata.json"),
+        )
+        # save fake features
+        metadata = save_features(
+            self.fake_features, str(model_path / f"{model_filename}.fake_features.st")
+        )
+        rasa.shared.utils.io.dump_obj_as_json_to_file(
+            model_path / f"{model_filename}.fake_features_metadata.json", metadata
         )
+
         entity_tag_specs = (
             [tag_spec._asdict() for tag_spec in self._entity_tag_specs]
             if self._entity_tag_specs
@@ -994,18 +1008,29 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted.
         """
         tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
-        loaded_data = rasa.utils.io.pickle_load(
-            model_path / f"{cls._metadata_filename()}.data_example.pkl"
+
+        # load data example
+        loaded_data = deserialize_nested_feature_arrays(
+            str(model_path / f"{cls._metadata_filename()}.data_example.st"),
+            str(model_path / f"{cls._metadata_filename()}.data_example_metadata.json"),
         )
-        label_data = rasa.utils.io.pickle_load(
-            model_path / f"{cls._metadata_filename()}.label_data.pkl"
+        # load label data
+        loaded_label_data = deserialize_nested_feature_arrays(
+            str(model_path / f"{cls._metadata_filename()}.label_data.st"),
+            str(model_path / f"{cls._metadata_filename()}.label_data_metadata.json"),
         )
-        fake_features = rasa.utils.io.pickle_load(
-            model_path / f"{cls._metadata_filename()}.fake_features.pkl"
+        label_data = RasaModelData(data=loaded_label_data)
+
+        # load fake features
+        metadata = rasa.shared.utils.io.read_json_file(
+            model_path / f"{cls._metadata_filename()}.fake_features_metadata.json"
         )
-        label_data = RasaModelData(data=label_data)
-        priority = rasa.utils.io.json_unpickle(
-            model_path / f"{cls._metadata_filename()}.priority.pkl"
+        fake_features = load_features(
+            str(model_path / f"{cls._metadata_filename()}.fake_features.st"), metadata
+        )
+
+        priority = rasa.shared.utils.io.read_json_file(
+            model_path / f"{cls._metadata_filename()}.priority.json"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
             model_path / f"{cls._metadata_filename()}.entity_tag_specs.json"
@@ -1023,8 +1048,8 @@ class TEDPolicy(Policy):
             )
             for tag_spec in entity_tag_specs
         ]
-        model_config = rasa.utils.io.pickle_load(
-            model_path / f"{cls._metadata_filename()}.meta.pkl"
+        model_config = rasa.shared.utils.io.read_json_file(
+            model_path / f"{cls._metadata_filename()}.meta.json"
         )
 
         return {
@@ -1070,7 +1095,7 @@ class TEDPolicy(Policy):
     ) -> TEDPolicy:
         featurizer = TrackerFeaturizer.load(model_path)
 
-        if not (model_path / f"{cls._metadata_filename()}.data_example.pkl").is_file():
+        if not (model_path / f"{cls._metadata_filename()}.data_example.st").is_file():
             return cls(
                 config,
                 model_storage,

rasa/core/policies/unexpected_intent_policy.py

@@ -5,6 +5,7 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
+
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -16,6 +17,7 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
+import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -103,8 +105,6 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
-
-import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -881,9 +881,12 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-        io_utils.pickle_dump(
-            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
-            self.label_quantiles,
+
+        from safetensors.numpy import save_file
+
+        save_file(
+            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
+            model_path / f"{self._metadata_filename()}.label_quantiles.st",
         )
 
     @classmethod
@@ -894,9 +897,14 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-        label_quantiles = io_utils.pickle_load(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
+
+        from safetensors.numpy import load_file
+
+        loaded_label_quantiles = load_file(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
         )
+        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
+
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

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/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__)
 
@@ -1688,7 +1687,7 @@ def run_interactive_learning(
         p = None
 
     app = run.configure_app(port=port, conversation_id="default", enable_api=True)
-    endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
+    endpoints = AvailableEndpoints.get_instance(server_args.get("endpoints"))
 
     # before_server_start handlers make sure the agent is loaded before the
     # interactive learning IO starts

rasa/core/utils.py

@@ -309,7 +309,7 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         return _log_and_get_default_number_of_workers()
 
     if env_value < 1:
-        structlogger.debug(
+        structlogger.warning(
             "server.worker.set_count.error_less_than_one",
             number_of_workers=env_value,
             event_info=f"Cannot set number of Sanic workers to the desired value "
@@ -318,14 +318,19 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         return _log_and_get_default_number_of_workers()
 
     if _lock_store_is_multi_worker_compatible(lock_store):
-        structlogger.debug(f"Using {env_value} Sanic workers.")
+        structlogger.debug(
+            "server.worker.set_count.success",
+            event_info=f"Using {env_value} Sanic workers.",
+            num_workers=env_value,
+        )
         return env_value
 
-    structlogger.debug(
+    structlogger.warning(
         "server.worker.set_count.error_no_lock_store",
         event_info=f"Unable to assign desired number of Sanic workers ({env_value}) as "
         f"no `RedisLockStore` or custom `LockStore` endpoint "
         f"configuration has been found.",
+        num_workers=env_value,
     )
     return _log_and_get_default_number_of_workers()