rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/cli/project_templates/telco/tests/e2e_test_cases/without_stub/general/human_handoff.yml

@@ -0,0 +1,35 @@
+test_cases:
+  - test_case: human handoff happy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=True)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=False)"
+                title: "No"
+    - user: "Yes"
+      assertions:
+        - bot_uttered:
+            utter_name: "utter_transferring_to_human"
+        - action_executed: action_human_handoff
+# ====================================================>
+  - test_case: human handoff unhappy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=True)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=False)"
+                title: "No"
+    - user: "No"
+      assertions:
+        - bot_uttered:
+            utter_name: "utter_human_handoff_cancelled"

rasa/cli/project_templates/telco/tests/e2e_test_cases/without_stub/general/patterns.yml

@@ -0,0 +1,23 @@
+test_cases:
+- test_case: test pattern search
+  steps:
+    - user: "how do you run a network speed test?"
+      assertions:
+        - generative_response_is_grounded:
+            threshold: 0.90
+            ground_truth: "You can run a network speed test using special software such as \"Fast.com\", \"Speedtest.net\", or Google's \"Internet speed test\". Alternatively, if you have our app, you can go to the Home menu, select WLAN speed test and run it. These tests measure your internet connection's performance by evaluating download and upload speeds, ping, and jitter."
+    - user: "what is the difference between restart and reset a router"
+      assertions:
+        - flow_completed:
+            flow_id: "pattern_search"
+        - generative_response_is_grounded:
+            threshold: 0.90
+            ground_truth: "Restarting or rebooting a router involves turning it off and back on without changing any settings, which can help resolve temporary issues like slow speeds or dropped connections. Resetting a router, however, restores it to factory settings, erasing all custom configurations such as the Wi-Fi name, password, and advanced settings. Resetting should only be done as a last resort when troubleshooting persistent problems."
+#
+- test_case: test pattern session start
+  steps:
+    - user: "/session_start"
+      assertions:
+        - flow_started: "pattern_session_start"
+        - bot_uttered:
+            utter_name: "utter_greeting"

rasa/cli/project_templates/tutorial/config.yml

@@ -1,5 +1,6 @@
 recipe: default.v1
 language: en
+assistant_id: placeholder_default
 pipeline:
 - name: CompactLLMCommandGenerator
   llm:
@@ -9,4 +10,4 @@ pipeline:
 
 policies:
   - name: FlowPolicy
-#  - name: EnterpriseSearchPolicy
+#  - name: EnterpriseSearchPolicy

rasa/cli/project_templates/tutorial/credentials.yml

@@ -31,3 +31,13 @@ rest:
 # for the Rasa Enterprise "channel", i.e. Talk to your bot and Share with guest testers.
 rasa:
   url: "http://localhost:5002/api"
+
+# The Browser Audio channel enables voice interactions with your assistant directly in the browser.
+# Used by the Rasa Voice Inspector, it provides speech-to-text and text-to-speech capabilities
+# through services like Deepgram.
+browser_audio:
+  server_url: localhost
+  asr:
+    name: deepgram
+  tts:
+    name: deepgram

rasa/cli/run.py

@@ -7,12 +7,12 @@ from rasa.api import run as rasa_run
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import run as arguments
 from rasa.cli.arguments.default_arguments import SkipYamlValidation
-from rasa.cli.utils import get_validated_path
+from rasa.core.config.configuration import (
+    Configuration,
+)
 from rasa.exceptions import ModelNotFound
 from rasa.shared.constants import (
     DEFAULT_ACTIONS_PATH,
-    DEFAULT_CREDENTIALS_PATH,
-    DEFAULT_ENDPOINTS_PATH,
     DEFAULT_MODELS_PATH,
     DOCS_BASE_URL,
 )
@@ -86,11 +86,10 @@ def run(args: argparse.Namespace) -> None:
     Args:
         args: The CLI arguments.
     """
-    args.endpoints = get_validated_path(
-        args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
-    )
-    args.credentials = get_validated_path(
-        args.credentials, "credentials", DEFAULT_CREDENTIALS_PATH, True
+    Configuration.initialise_endpoints(
+        args.endpoints,
+    ).initialise_sub_agents(args.sub_agents).initialise_credentials(
+        args.credentials,
     )
 
     if SkipYamlValidation.DOMAIN.value in args.skip_yaml_validation:
@@ -109,7 +108,6 @@ def run(args: argparse.Namespace) -> None:
     # configured
 
     import rasa.model
-    from rasa.core.available_endpoints import AvailableEndpoints
 
     # start server if remote storage is configured
     if args.remote_storage is not None:
@@ -117,7 +115,7 @@ def run(args: argparse.Namespace) -> None:
         return
 
     # start server if model server is configured
-    endpoints = AvailableEndpoints.get_instance(args.endpoints)
+    endpoints = Configuration.get_instance().endpoints
     model_server = endpoints.model if endpoints and endpoints.model else None
     if model_server is not None:
         rasa_run(**vars(args))

rasa/cli/scaffold.py

@@ -5,6 +5,9 @@ from collections import defaultdict
 from enum import Enum
 from typing import List, Text
 
+import randomname
+import structlog
+
 from rasa import telemetry
 from rasa.api import train
 from rasa.cli import SubParsersAction
@@ -16,21 +19,38 @@ from rasa.shared.constants import (
     DEFAULT_MODELS_PATH,
     DOCS_BASE_URL,
 )
+from rasa.shared.utils import yaml
 from rasa.shared.utils.cli import print_error_and_exit, print_success
 
+structlogger = structlog.get_logger(__name__)
+
 
 class ProjectTemplateName(Enum):
     """Enum of CALM project templates."""
 
     DEFAULT = "default"
     TUTORIAL = "tutorial"
+    BASIC = "basic"
+    FINANCE = "finance"
+    TELCO = "telco"
 
     def __str__(self) -> str:
         return self.value
 
+    @classmethod
+    def get_all_values(cls) -> List[str]:
+        return [name.value for name in cls]
+
+    @classmethod
+    def supported_values(cls) -> str:
+        return ", ".join(cls.get_all_values())
+
 
 template_domain_path = defaultdict(lambda: DEFAULT_DOMAIN_PATH)
 template_domain_path[ProjectTemplateName.DEFAULT] = "domain"
+template_domain_path[ProjectTemplateName.BASIC] = "domain"
+template_domain_path[ProjectTemplateName.FINANCE] = "domain"
+template_domain_path[ProjectTemplateName.TELCO] = "domain"
 
 
 def add_subparser(
@@ -84,10 +104,10 @@ def print_train_or_instructions(args: argparse.Namespace) -> None:
     if should_train:
         print_success("Training an initial model...")
         training_result = train(
-            template_domain_path[args.template],
-            DEFAULT_CONFIG_PATH,
-            DEFAULT_DATA_PATH,
-            DEFAULT_MODELS_PATH,
+            domain=template_domain_path[args.template],
+            config=DEFAULT_CONFIG_PATH,
+            training_files=DEFAULT_DATA_PATH,
+            output=DEFAULT_MODELS_PATH,
         )
         args.model = training_result.model
 
@@ -159,9 +179,33 @@ def create_initial_project(
     path: Text, template: ProjectTemplateName = ProjectTemplateName.DEFAULT
 ) -> None:
     """Creates directory structure and templates for initial project."""
-    from distutils.dir_util import copy_tree
+    import distutils.dir_util as dir_util
+
+    # clear the cache of the copy_tree function, this avoids issues if
+    # a project directory existed before and we removed folders in it
+    # with shutil.rmtree. see
+    # https://stackoverflow.com/questions/9160227/dir-util-copy-tree-fails-after-shutil-rmtree
+    if hasattr(dir_util, "_path_created"):
+        dir_util._path_created.clear()
+    else:
+        dir_util.SkipRepeatAbsolutePaths.clear()  # type: ignore[attr-defined]
+    dir_util.copy_tree(scaffold_path(template), path)
 
-    copy_tree(scaffold_path(template), path)
+    create_random_assistant_id(path)
+
+
+def create_random_assistant_id(path: Text) -> None:
+    """Create a random assistant id."""
+    assistant_id = f"{randomname.get_name()}"
+    config = yaml.read_yaml_file(os.path.join(path, "config.yml"))
+
+    if isinstance(config, dict):
+        config["assistant_id"] = assistant_id
+        yaml.write_yaml(config, os.path.join(path, "config.yml"))
+    else:
+        structlogger.warning(
+            "cli.scaffold.create_random_assistant_id.invalid_config", config=config
+        )
 
 
 def scaffold_path(template: ProjectTemplateName) -> Text:

rasa/cli/shell.py

@@ -1,12 +1,14 @@
 import argparse
 import logging
 import uuid
+from pathlib import Path
 from typing import List
 
 from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.cli.arguments.default_arguments import add_sub_agents_param
+from rasa.core.config.configuration import Configuration
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.exceptions import ModelNotFound
 from rasa.model import get_local_model
@@ -45,6 +47,8 @@ def add_subparser(
         help="Set the conversation ID.",
     )
 
+    add_sub_agents_param(shell_parser)
+
     run_subparsers = shell_parser.add_subparsers()
 
     shell_nlu_subparser = run_subparsers.add_parser(
@@ -64,7 +68,7 @@ def add_subparser(
 def shell_nlu(args: argparse.Namespace) -> None:
     """Talk with an NLU only bot though the command line."""
     import rasa.nlu.run
-    from rasa.cli.utils import get_validated_path
+    from rasa.cli.validation.config_path_validation import get_validated_path
     from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     args.connector = "cmdline"
@@ -102,15 +106,16 @@ def shell_nlu(args: argparse.Namespace) -> None:
 
 def shell(args: argparse.Namespace) -> None:
     """Talk with a bot though the command line."""
-    from rasa.cli.utils import get_validated_path
+    from rasa.cli.validation.config_path_validation import get_validated_path
     from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     args.connector = "cmdline"
     # Load endpoints with proper endpoint file location
     # This will initialise the endpoints singleton properly so that
     # it can be used safely throughout the codebase with
-    # `AvailableEndpoints.get_instance()`
-    AvailableEndpoints.get_instance(args.endpoints)
+    # `Configuration.get_instance().endpoints`
+    Configuration.initialise_endpoints(endpoints_path=Path(args.endpoints))
+    Configuration.initialise_sub_agents(args.sub_agents)
     model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
 
     try:

rasa/cli/studio/studio.py

@@ -12,7 +12,7 @@ import rasa.cli.studio.train
 import rasa.cli.studio.upload
 import rasa.shared.utils.cli
 from rasa.cli import SubParsersAction
-from rasa.cli.utils import get_validated_path
+from rasa.cli.validation.config_path_validation import get_validated_path
 from rasa.shared.constants import DEFAULT_DOMAIN_PATH, DEFAULT_DOMAIN_PATHS
 from rasa.studio.auth import StudioAuth
 from rasa.studio.config import StudioConfig

rasa/cli/test.py

@@ -11,6 +11,13 @@ import rasa.shared.utils.io
 import rasa.utils.common
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import test as arguments
+from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.config.configuration import (
+    Configuration,
+    CredentialsConfigPath,
+    EndpointsConfigPath,
+    MessageProcessingConfigPath,
+)
 from rasa.core.constants import (
     FAILED_STORIES_FILE,
     STORIES_WITH_WARNINGS_FILE,
@@ -100,10 +107,16 @@ async def run_core_test_async(args: argparse.Namespace) -> None:
         test_core_models_in_directory,
     )
 
-    stories = rasa.cli.utils.get_validated_path(
-        args.stories, "stories", DEFAULT_DATA_PATH
+    Configuration.initialise_endpoints(
+        endpoints_path=EndpointsConfigPath.validate(),
+    ).initialise_credentials(
+        credentials_path=CredentialsConfigPath.validate()
+    ).initialise_message_processing(
+        message_processing_config_path=MessageProcessingConfigPath.validate()
     )
 
+    stories = get_validated_path(args.stories, "stories", DEFAULT_DATA_PATH)
+
     output = args.out or DEFAULT_RESULTS_PATH
     args.errors = not args.no_errors
     args.warnings = not args.no_warnings
@@ -121,9 +134,7 @@ async def run_core_test_async(args: argparse.Namespace) -> None:
         return
 
     if isinstance(args.model, str):
-        model_path = rasa.cli.utils.get_validated_path(
-            args.model, "model", DEFAULT_MODELS_PATH
-        )
+        model_path = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
 
         if args.evaluate_model_directory:
             await test_core_models_in_directory(
@@ -182,9 +193,7 @@ async def run_nlu_test_async(
         test_nlu,
     )
 
-    data_path = str(
-        rasa.cli.utils.get_validated_path(data_path, "nlu", DEFAULT_DATA_PATH)
-    )
+    data_path = str(get_validated_path(data_path, "nlu", DEFAULT_DATA_PATH))
     test_data_importer = TrainingDataImporter.load_from_dict(
         training_data_paths=[data_path], domain_path=domain_path
     )
@@ -225,18 +234,29 @@ async def run_nlu_test_async(
         )
     elif cross_validation:
         logger.info("Test model using cross validation.")
-        # FIXME: supporting Union[Path, Text] down the chain
-        # is the proper fix and needs more work
-        config = str(
-            rasa.cli.utils.get_validated_path(config, "config", DEFAULT_CONFIG_PATH)
+
+        Configuration.initialise_endpoints(
+            endpoints_path=EndpointsConfigPath.validate(),
+        ).initialise_credentials(
+            credentials_path=CredentialsConfigPath.validate()
+        ).initialise_message_processing(
+            message_processing_config_path=MessageProcessingConfigPath.validate(config),
         )
+
+        config = str(get_validated_path(config, "config", DEFAULT_CONFIG_PATH))
         config_importer = TrainingDataImporter.load_from_dict(config_path=config)
 
         config_dict = config_importer.get_config()
         await perform_nlu_cross_validation(config_dict, nlu_data, output, all_args)
     else:
-        model_path = rasa.cli.utils.get_validated_path(
-            models_path, "model", DEFAULT_MODELS_PATH
+        model_path = get_validated_path(models_path, "model", DEFAULT_MODELS_PATH)
+
+        Configuration.initialise_endpoints(
+            endpoints_path=EndpointsConfigPath.validate(),
+        ).initialise_credentials(
+            credentials_path=CredentialsConfigPath.validate()
+        ).initialise_message_processing(
+            message_processing_config_path=MessageProcessingConfigPath.validate(config),
         )
 
         await test_nlu(model_path, data_path, output, all_args, domain_path=domain_path)

rasa/cli/train.py

@@ -7,15 +7,18 @@ from typing import Dict, List, Optional, Text, Union
 import structlog
 
 import rasa.cli.arguments.train as train_arguments
-import rasa.cli.utils
-import rasa.core.utils
-import rasa.utils.common
 from rasa.cli import SubParsersAction
+from rasa.cli.validation.bot_config import validate_files
+from rasa.cli.validation.config_path_validation import (
+    get_validated_config,
+    get_validated_path,
+)
+from rasa.core.config.configuration import Configuration
 from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.nlg.generator import NaturalLanguageGenerator
 from rasa.core.train import do_compare_training
 from rasa.engine.validation import validate_api_type_config_key_usage
-from rasa.exceptions import ValidationError
+from rasa.exceptions import DetailedRasaException
 from rasa.shared.constants import (
     CONFIG_MANDATORY_KEYS,
     CONFIG_MANDATORY_KEYS_CORE,
@@ -74,7 +77,9 @@ def add_subparser(
 
 def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
     try:
-        endpoints = rasa.core.utils.read_endpoints_from_path(endpoint)
+        endpoints = Configuration.initialise_endpoints(
+            endpoints_path=endpoint
+        ).endpoints
         if endpoints.nlg is not None:
             validate_api_type_config_key_usage(
                 endpoints.nlg.kwargs,
@@ -82,7 +87,7 @@ def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
                 ContextualResponseRephraser.__name__,
             )
         NaturalLanguageGenerator.create(endpoints.nlg)
-    except ValidationError as e:
+    except DetailedRasaException as e:
         structlogger.error(
             e.code,
             event_info=e.info,
@@ -115,21 +120,18 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
     """
     from rasa.api import train as train_all
 
-    domain = rasa.cli.utils.get_validated_path(
+    domain = get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
     )
-    config = rasa.cli.utils.get_validated_config(args.config, CONFIG_MANDATORY_KEYS)
+    config = get_validated_config(args.config, CONFIG_MANDATORY_KEYS)
 
     # Validates and loads endpoints with proper endpoint file location
-    # This will initialise the endpoints singleton properly so that
-    # it can be used safely throughout the codebase with
-    # `AvailableEndpoints.get_instance()`
+    # TODO(Radovan): this should be probably be done in Configuration
     _check_nlg_endpoint_validity(args.endpoints)
+    Configuration.initialise_sub_agents(args.sub_agents)
 
     training_files = [
-        rasa.cli.utils.get_validated_path(
-            f, "data", DEFAULT_DATA_PATH, none_is_valid=True
-        )
+        get_validated_path(f, "data", DEFAULT_DATA_PATH, none_is_valid=True)
         for f in args.data
     ]
 
@@ -143,15 +145,17 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
             event_info="Started validating domain and training data...",
         )
 
-        rasa.cli.utils.validate_files(
+        validate_files(
             args.fail_on_validation_warnings,
             args.validation_max_history,
             training_data_importer,
+            sub_agents=args.sub_agents,
         )
 
     training_result = train_all(
         domain=domain,
         config=config,
+        endpoints=args.endpoints,
         training_files=training_files,
         output=args.out,
         dry_run=args.dry_run,
@@ -168,6 +172,7 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         file_importer=training_data_importer,
         keep_local_model_copy=args.keep_local_model_copy,
         remote_root_only=args.remote_root_only,
+        sub_agents=args.sub_agents,
     )
     if training_result.code != 0 and can_exit:
         display_research_study_prompt()
@@ -177,13 +182,19 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
 
 
 def _model_for_finetuning(args: argparse.Namespace) -> Optional[Text]:
-    if args.finetune == train_arguments.USE_LATEST_MODEL_FOR_FINE_TUNING:
-        # We use this constant to signal that the user specified `--finetune` but
-        # didn't provide a path to a model. In this case we try to load the latest
-        # model from the output directory (that's usually models/).
-        return args.out
-    else:
-        return args.finetune
+    if args.finetune is not None:
+        structlogger.error(
+            "cli.train.incremental_training_not_supported",
+            event_info=(
+                "Incremental training (--finetune) is "
+                "not supported in Rasa 3.14.0 onwards. "
+                "Please retrain your model from scratch "
+                "if you have updated your configuration. "
+            ),
+        )
+        display_research_study_prompt()
+        sys.exit(1)
+    return None
 
 
 def run_core_training(args: argparse.Namespace) -> Optional[Text]:
@@ -197,10 +208,10 @@ def run_core_training(args: argparse.Namespace) -> Optional[Text]:
     """
     from rasa.model_training import train_core
 
-    args.domain = rasa.cli.utils.get_validated_path(
+    args.domain = get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
     )
-    story_file = rasa.cli.utils.get_validated_path(
+    story_file = get_validated_path(
         args.stories, "stories", DEFAULT_DATA_PATH, none_is_valid=True
     )
     additional_arguments = {
@@ -213,9 +224,11 @@ def run_core_training(args: argparse.Namespace) -> Optional[Text]:
         if isinstance(args.config, list):
             args.config = args.config[0]
 
-        config = rasa.cli.utils.get_validated_config(
-            args.config, CONFIG_MANDATORY_KEYS_CORE
-        )
+        config = get_validated_config(args.config, CONFIG_MANDATORY_KEYS_CORE)
+
+        Configuration.initialise_message_processing(
+            message_processing_config_path=Path(config)
+        ).initialise_empty_endpoints()
 
         return asyncio.run(
             train_core(
@@ -231,6 +244,7 @@ def run_core_training(args: argparse.Namespace) -> Optional[Text]:
             )
         )
     else:
+        Configuration.initialise_empty()
         asyncio.run(do_compare_training(args, story_file, additional_arguments))
         return None
 
@@ -246,13 +260,13 @@ def run_nlu_training(args: argparse.Namespace) -> Optional[Text]:
     """
     from rasa.model_training import train_nlu
 
-    config = rasa.cli.utils.get_validated_config(args.config, CONFIG_MANDATORY_KEYS_NLU)
-    nlu_data = rasa.cli.utils.get_validated_path(
+    config = get_validated_config(args.config, CONFIG_MANDATORY_KEYS_NLU)
+    nlu_data = get_validated_path(
         args.nlu, "nlu", DEFAULT_DATA_PATH, none_is_valid=True
     )
 
     if args.domain:
-        args.domain = rasa.cli.utils.get_validated_path(
+        args.domain = get_validated_path(
             args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
         )