rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

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,10 +7,13 @@ 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
@@ -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,
@@ -115,21 +120,17 @@ 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)
 
     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 +144,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 +171,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 +181,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 +207,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 +223,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 +243,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 +259,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
         )
 

rasa/cli/utils.py

@@ -1,415 +1,23 @@
-import argparse
 import importlib
 import json
 import os
 import sys
-import time
 from pathlib import Path
 from types import FrameType
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union, overload
+from typing import TYPE_CHECKING, Any, Dict, List, Text
 
-import randomname
 import structlog
 
-import rasa.shared.utils.cli
 import rasa.shared.utils.io
-from rasa import telemetry
-from rasa.exceptions import ModelNotFound, ValidationError
-from rasa.shared.constants import (
-    ASSISTANT_ID_DEFAULT_VALUE,
-    ASSISTANT_ID_KEY,
-    DEFAULT_CONFIG_PATH,
-)
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.utils.common import display_research_study_prompt
-from rasa.shared.utils.yaml import read_config_file
-from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from questionary import Question
-    from typing_extensions import Literal
-
-    from rasa.validator import Validator
 
 structlogger = structlog.get_logger()
 
 FREE_TEXT_INPUT_PROMPT = "Type out your own message..."
 
 
-@overload
-def get_validated_path(
-    current: Optional[Union[Path, Text]],
-    parameter: Text,
-    default: Optional[Union[Path, Text, List[Text]]] = ...,
-    none_is_valid: "Literal[False]" = ...,
-) -> Union[Path, Text]: ...
-
-
-@overload
-def get_validated_path(
-    current: Optional[Union[Path, Text]],
-    parameter: Text,
-    default: Optional[Union[Path, Text, List[Text]]] = ...,
-    none_is_valid: "Literal[True]" = ...,
-) -> Optional[Union[Path, Text]]: ...
-
-
-def get_validated_path(
-    current: Optional[Union[Path, Text]],
-    parameter: Text,
-    default: Optional[Union[Path, Text, List[Text]]] = None,
-    none_is_valid: bool = False,
-) -> Optional[Union[Path, Text]]:
-    """Checks whether a file path or its default value is valid and returns it.
-
-    Args:
-        current: The parsed value.
-        parameter: The name of the parameter.
-        default: one or multiple default values of the parameter.
-        none_is_valid: `True` if `None` is valid value for the path,
-                        else `False``
-
-    Returns:
-        The current value if valid,
-        otherwise one of the default values of the argument if valid,
-        otherwise `None` if allowed,
-        otherwise raises an error and exits.
-    """
-    if current and os.path.exists(current):
-        return current
-
-    if parameter == "model":
-        raise ModelNotFound(
-            f"The provided model path '{current}' could not be found. "
-            "Provide an existing model path."
-        )
-
-    # try to find a valid option among the defaults
-    if isinstance(default, str) or isinstance(default, Path):
-        default_options = [str(default)]
-    elif isinstance(default, list):
-        default_options = default
-    else:
-        default_options = []
-
-    valid_options = (option for option in default_options if os.path.exists(option))
-    chosen_option = next(valid_options, None)
-
-    # warn and log if user-chosen parameter wasn't found and thus overwritten
-    if chosen_option:
-        shared_info = f"Using default location '{chosen_option}' instead."
-        if current is None:
-            structlogger.debug(
-                "cli.get_validated_path.parameter_not_set",
-                parameter=parameter,
-                event_info=(f"Parameter '{parameter}' was not set. {shared_info}"),
-            )
-        elif current not in default_options:
-            structlogger.warn(
-                "cli.get_validated_path.path_does_not_exists",
-                path=current,
-                event_info=(
-                    f"The path '{current}' does not seem to exist. {shared_info}"
-                ),
-            )
-
-    if chosen_option is None and not none_is_valid:
-        cancel_cause_not_found(current, parameter, default)
-
-    return chosen_option
-
-
-def missing_config_keys(
-    path: Union["Path", Text], mandatory_keys: List[Text]
-) -> List[Text]:
-    """Checks whether the config file at `path` contains the `mandatory_keys`.
-
-    Args:
-        path: The path to the config file.
-        mandatory_keys: A list of mandatory config keys.
-
-    Returns:
-        The list of missing config keys.
-    """
-    if not os.path.exists(path):
-        return mandatory_keys
-
-    config_data = read_config_file(path)
-
-    return [k for k in mandatory_keys if k not in config_data or config_data[k] is None]
-
-
-def validate_assistant_id_in_config(config_file: Union["Path", Text]) -> None:
-    """Verifies that the assistant_id key exists and has a unique value in config.
-
-    Issues a warning if the key does not exist or has the default value and replaces it
-    with a pseudo-random string value.
-    """
-    config_data = read_config_file(config_file, reader_type=["safe", "rt"])
-    assistant_id = config_data.get(ASSISTANT_ID_KEY)
-
-    if assistant_id is None or assistant_id == ASSISTANT_ID_DEFAULT_VALUE:
-        structlogger.warn(
-            "cli.validate_assistant_id_in_config.missing_unique_assistant_id_key",
-            config=config_file,
-            missing_key=ASSISTANT_ID_KEY,
-            event_info=(
-                f"The config file '{config_file!s}' is "
-                f"missing a unique value for the "
-                f"'{ASSISTANT_ID_KEY}' mandatory key. "
-                f"Proceeding with generating a random "
-                f"value and overwriting the '{ASSISTANT_ID_KEY}'"
-                f" in the config file."
-            ),
-        )
-
-        # add random value for assistant id, overwrite config file
-        time_format = "%Y%m%d-%H%M%S"
-        config_data[ASSISTANT_ID_KEY] = (
-            f"{time.strftime(time_format)}-{randomname.get_name()}"
-        )
-
-        write_yaml(data=config_data, target=config_file, should_preserve_key_order=True)
-
-    return
-
-
-def validate_config_path(
-    config: Optional[Union[Text, "Path"]],
-    default_config: Text = DEFAULT_CONFIG_PATH,
-) -> Text:
-    """Verifies that the config path exists.
-
-    Exit if the config file does not exist.
-
-    Args:
-        config: Path to the config file.
-        default_config: default config to use if the file at `config` doesn't exist.
-
-    Returns: The path to the config file.
-    """
-    config = rasa.cli.utils.get_validated_path(config, "config", default_config)
-
-    if not config or not os.path.exists(config):
-        display_research_study_prompt()
-        raise ValidationError(
-            code="cli.validate_config_path.does_not_exists",
-            config=config,
-            event_info=(
-                f"The config file '{config}' does not exist. "
-                f"Use '--config' to specify a valid config file."
-            ),
-        )
-
-    return str(config)
-
-
-def validate_mandatory_config_keys(
-    config: Union[Text, "Path"],
-    mandatory_keys: List[Text],
-) -> Text:
-    """Get a config from a config file and check if it is valid.
-
-    Exit if the config isn't valid.
-
-    Args:
-        config: Path to the config file.
-        mandatory_keys: The keys that have to be specified in the config file.
-
-    Returns: The path to the config file if the config is valid.
-    """
-    missing_keys = set(rasa.cli.utils.missing_config_keys(config, mandatory_keys))
-    if missing_keys:
-        display_research_study_prompt()
-        raise ValidationError(
-            code="cli.validate_mandatory_config_keys.missing_keys",
-            config=config,
-            missing_keys=missing_keys,
-            event_info=(
-                "The config file '{}' is missing mandatory parameters: "
-                "'{}'. Add missing parameters to config file and try again.".format(
-                    config, "', '".join(missing_keys)
-                )
-            ),
-        )
-
-    return str(config)
-
-
-def get_validated_config(
-    config: Optional[Union[Text, "Path"]],
-    mandatory_keys: List[Text],
-    default_config: Text = DEFAULT_CONFIG_PATH,
-) -> Text:
-    """Validates config and returns path to validated config file."""
-    config = validate_config_path(config, default_config)
-    validate_assistant_id_in_config(config)
-
-    config = validate_mandatory_config_keys(config, mandatory_keys)
-
-    return config
-
-
-def validate_files(
-    fail_on_warnings: bool,
-    max_history: Optional[int],
-    importer: TrainingDataImporter,
-    stories_only: bool = False,
-    flows_only: bool = False,
-    translations_only: bool = False,
-) -> None:
-    """Validates either the story structure or the entire project.
-
-    Args:
-        fail_on_warnings: `True` if the process should exit with a non-zero status
-        max_history: The max history to use when validating the story structure.
-        importer: The `TrainingDataImporter` to use to load the training data.
-        stories_only: If `True`, only the story structure is validated.
-        flows_only: If `True`, only the flows are validated.
-        translations_only: If `True`, only the translations data is validated.
-    """
-    from rasa.validator import Validator
-
-    validator = Validator.from_importer(importer)
-
-    if stories_only:
-        all_good = _validate_story_structure(validator, max_history, fail_on_warnings)
-    elif flows_only:
-        all_good = validator.verify_flows()
-    elif translations_only:
-        all_good = validator.verify_translations()
-    else:
-        if importer.get_domain().is_empty():
-            structlogger.error(
-                "cli.validate_files.empty_domain",
-                event_info="Encountered empty domain during validation.",
-            )
-            display_research_study_prompt()
-            raise ValidationError(
-                code="cli.validate_files.empty_domain",
-                event_info="Encountered empty domain during validation.",
-            )
-
-        valid_domain = _validate_domain(validator)
-        valid_nlu = _validate_nlu(validator, fail_on_warnings)
-        valid_stories = _validate_story_structure(
-            validator, max_history, fail_on_warnings
-        )
-        valid_flows = validator.verify_flows()
-        if validator.config:
-            valid_translations = validator.verify_translations(summary_mode=True)
-        else:
-            valid_translations = True
-        valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
-
-        all_good = (
-            valid_domain
-            and valid_nlu
-            and valid_stories
-            and valid_flows
-            and valid_translations
-            and valid_CALM_slot_mappings
-        )
-
-    if validator.config:
-        validator.warn_if_config_mandatory_keys_are_not_set()
-
-    telemetry.track_validate_files(all_good)
-    if not all_good:
-        structlogger.error(
-            "cli.validate_files.project_validation_error",
-            event_info="Project validation completed with errors.",
-        )
-        display_research_study_prompt()
-        raise ValidationError(
-            code="cli.validate_files.project_validation_error",
-            event_info="Project validation completed with errors.",
-        )
-
-
-def _validate_domain(validator: "Validator") -> bool:
-    valid_domain_validity = validator.verify_domain_validity()
-    valid_actions_in_stories_rules = validator.verify_actions_in_stories_rules()
-    valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
-    valid_form_slots = validator.verify_form_slots()
-    valid_slot_mappings = validator.verify_slot_mappings()
-    valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
-    valid_buttons = validator.validate_button_payloads()
-    valid_slot_validation = validator.verify_slot_validation()
-    valid_conditional_responses = (
-        validator.validate_conditional_response_variation_predicates()
-    )
-    return (
-        valid_domain_validity
-        and valid_actions_in_stories_rules
-        and valid_forms_in_stories_rules
-        and valid_form_slots
-        and valid_slot_mappings
-        and valid_responses
-        and valid_buttons
-        and valid_slot_validation
-        and valid_conditional_responses
-    )
-
-
-def _validate_nlu(validator: "Validator", fail_on_warnings: bool) -> bool:
-    return validator.verify_nlu(not fail_on_warnings)
-
-
-def _validate_story_structure(
-    validator: "Validator", max_history: Optional[int], fail_on_warnings: bool
-) -> bool:
-    # Check if a valid setting for `max_history` was given
-    if isinstance(max_history, int) and max_history < 1:
-        raise argparse.ArgumentTypeError(
-            f"The value of `--max-history {max_history}` is not a positive integer."
-        )
-
-    return validator.verify_story_structure(
-        not fail_on_warnings, max_history=max_history
-    )
-
-
-def cancel_cause_not_found(
-    current: Optional[Union["Path", Text]],
-    parameter: Text,
-    default: Optional[Union["Path", Text, List[Text]]],
-) -> None:
-    """Exits with an error because the given path was not valid.
-
-    Args:
-        current: The path given by the user.
-        parameter: The name of the parameter.
-        default: The default value of the parameter.
-
-    """
-    default_clause = ""
-    if default and isinstance(default, str):
-        default_clause = f"use the default location ('{default}') or"
-    elif default and isinstance(default, list):
-        default_clause = f"use one of the default locations ({', '.join(default)}) or"
-
-    structlogger.error(
-        "cli.path_does_not_exist",
-        path=current,
-        event_info=(
-            f"The path '{current}' does not exist. "
-            f"Please make sure to {default_clause} specify it "
-            f"with '--{parameter}'."
-        ),
-    )
-    display_research_study_prompt()
-    raise ValidationError(
-        code="cli.path_does_not_exist",
-        path=current,
-        event_info=(
-            f"The path '{current}' does not exist. "
-            f"Please make sure to {default_clause} specify it "
-            f"with '--{parameter}'."
-        ),
-    )
-
-
 def parse_last_positional_argument_as_model_path() -> None:
     """Fixes the parsing of a potential positional model path argument."""
     if (