let rasa interactive automatically do rasa interactive core when no nlu data

changelog/4799.bugfix.rst

@@ -0,0 +1 @@
+Running ``rasa interactive`` with no NLU data now works, with the functionality of ``rasa interactive core``.

changelog/4834.improvement.rst

@@ -0,0 +1,7 @@
+Made it explicit that interactive learning does not work with NLU-only models.
+
+Interactive learning no longer trains NLU-only models if no model is provided
+and no core data is provided.
+
+Made the ``_story_files`` and ``_nlu_files`` of the ``RasaFileImporter`` class
+public. They are now ``story_files`` and ``nlu_files``.

rasa/cli/interactive.py

@@ -1,20 +1,15 @@
 import argparse
 import os
-from typing import List, Text
+from typing import List, Optional, Text
 
+from rasa.cli import utils
 import rasa.cli.train as train
 from rasa.cli.arguments import interactive as arguments
 from rasa import data, model
 
-
 # noinspection PyProtectedMember
-from rasa.cli.utils import get_validated_path, print_error
-from rasa.constants import (
-    DEFAULT_DATA_PATH,
-    DEFAULT_MODELS_PATH,
-    DEFAULT_ENDPOINTS_PATH,
-)
-from rasa.model import get_latest_model
+from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_ENDPOINTS_PATH
+from rasa.importers.rasa import RasaFileImporter
 
 
 def add_subparser(
@@ -28,7 +23,7 @@ def add_subparser(
         help="Starts an interactive learning session to create new training data for a "
         "Rasa model by chatting.",
     )
-    interactive_parser.set_defaults(func=interactive)
+    interactive_parser.set_defaults(func=interactive, core_only=False)
     interactive_parser.add_argument(
         "--e2e",
         action="store_true",
@@ -45,20 +40,37 @@ def add_subparser(
         "for a Rasa Core model by chatting. Uses the 'RegexInterpreter', i.e. "
         "`/<intent>` input format.",
     )
-    interactive_core_parser.set_defaults(func=interactive_core)
+    interactive_core_parser.set_defaults(func=interactive, core_only=True)
 
     arguments.set_interactive_arguments(interactive_parser)
     arguments.set_interactive_core_arguments(interactive_core_parser)
 
 
-def interactive(args: argparse.Namespace):
+def interactive(args: argparse.Namespace) -> None:
     _set_not_required_args(args)
+    file_importer = RasaFileImporter(args.config, args.domain, args.data)
 
     if args.model is None:
-        check_training_data(args)
-        zipped_model = train.train(args)
+        story_files = file_importer.story_files
+        if not story_files:
+            utils.print_error_and_exit(
+                "Could not run interactive learning without either core data or a model containing core data."
+            )
+
+        zipped_model = train.train_core(args) if args.core_only else train.train(args)
+        if not zipped_model:
+            utils.print_error_and_exit(
+                "Could not train an initial model. Either pass paths "
+                "to the relevant training files (`--data`, `--config`, `--domain`), "
+                "or use 'rasa train' to train a model."
+            )
     else:
         zipped_model = get_provided_model(args.model)
+        if not (zipped_model and os.path.exists(zipped_model)):
+            utils.print_error_and_exit(
+                f"Interactive learning process cannot be started as no initial model was "
+                f"found at path '{args.model}'.  Use 'rasa train' to train a model."
+            )
 
     perform_interactive_learning(args, zipped_model)
 
@@ -68,57 +80,30 @@ def _set_not_required_args(args: argparse.Namespace) -> None:
     args.store_uncompressed = False
 
 
-def interactive_core(args: argparse.Namespace):
-    _set_not_required_args(args)
-
-    if args.model is None:
-        zipped_model = train.train_core(args)
-    else:
-        zipped_model = get_provided_model(args.model)
-
-    perform_interactive_learning(args, zipped_model)
-
-
-def perform_interactive_learning(args, zipped_model) -> None:
+def perform_interactive_learning(args: argparse.Namespace, zipped_model: Text) -> None:
     from rasa.core.train import do_interactive_learning
 
-    if zipped_model and os.path.exists(zipped_model):
-        args.model = zipped_model
-
-        with model.unpack_model(zipped_model) as model_path:
-            args.core, args.nlu = model.get_model_subdirectories(model_path)
-            stories_directory = data.get_core_directory(args.data)
+    args.model = zipped_model
 
-            args.endpoints = get_validated_path(
-                args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
+    with model.unpack_model(zipped_model) as model_path:
+        args.core, args.nlu = model.get_model_subdirectories(model_path)
+        if args.core is None:
+            utils.print_error_and_exit(
+                "Can not run interactive learning on an NLU-only model."
             )
+        stories_directory = data.get_core_directory(args.data)
 
-            do_interactive_learning(args, stories_directory)
-    else:
-        print_error(
-            "Interactive learning process cannot be started as no initial model was "
-            "found.  Use 'rasa train' to train a model."
+        args.endpoints = utils.get_validated_path(
+            args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
         )
 
+        do_interactive_learning(args, stories_directory)
+
 
-def get_provided_model(arg_model: Text):
-    model_path = get_validated_path(arg_model, "model", DEFAULT_MODELS_PATH)
+def get_provided_model(arg_model: Text) -> Optional[Text]:
+    model_path = utils.get_validated_path(arg_model, "model", DEFAULT_MODELS_PATH)
 
     if os.path.isdir(model_path):
-        model_path = get_latest_model(model_path)
+        model_path = model.get_latest_model(model_path)
 
     return model_path
-
-
-def check_training_data(args) -> None:
-    training_files = [
-        get_validated_path(f, "data", DEFAULT_DATA_PATH, none_is_valid=True)
-        for f in args.data
-    ]
-    story_files, nlu_files = data.get_core_nlu_files(training_files)
-    if not story_files or not nlu_files:
-        print_error(
-            "Cannot train initial Rasa model. Please provide NLU and Core data "
-            "using the '--data' argument."
-        )
-        exit(1)

rasa/core/train.py

@@ -173,17 +173,12 @@ async def do_compare_training(
 
 
 def do_interactive_learning(
-    args: argparse.Namespace,
-    stories: Optional[Text] = None,
-    additional_arguments: Dict[Text, typing.Any] = None,
+    args: argparse.Namespace, stories: Optional[Text] = None,
 ):
     from rasa.core.training import interactive
 
     interactive.run_interactive_learning(
-        stories,
-        skip_visualization=args.skip_visualization,
-        server_args=args.__dict__,
-        additional_arguments=additional_arguments,
+        stories, skip_visualization=args.skip_visualization, server_args=args.__dict__,
     )