rasa-pro 3.11.3__py3-none-any.whl

rasa/cli/export.py

@@ -0,0 +1,250 @@
+import argparse
+import asyncio
+import logging
+import typing
+from typing import List, Text, Optional
+
+from rasa import telemetry
+from rasa.cli import SubParsersAction
+import rasa.core.utils
+import rasa.shared.utils.cli
+import rasa.utils.common
+from rasa.cli.arguments import export as arguments
+from rasa.shared.constants import DOCS_URL_EVENT_BROKERS, DOCS_URL_TRACKER_STORES
+from rasa.exceptions import PublishingError
+from rasa.shared.exceptions import RasaException
+from rasa.core.brokers.pika import PikaEventBroker
+
+if typing.TYPE_CHECKING:
+    from rasa.core.brokers.broker import EventBroker
+    from rasa.core.tracker_store import TrackerStore
+    from rasa.core.exporter import Exporter
+    from rasa.core.utils import AvailableEndpoints
+
+logger = logging.getLogger(__name__)
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add subparser for `rasa export`.
+
+    Args:
+        subparsers: Subparsers action object to which `argparse.ArgumentParser`
+            objects can be added.
+        parents: `argparse.ArgumentParser` objects whose arguments should also be
+            included.
+    """
+    export_parser = subparsers.add_parser(
+        "export",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Export conversations using an event broker.",
+    )
+    export_parser.set_defaults(func=export_trackers)
+
+    arguments.set_export_arguments(export_parser)
+
+
+def _get_tracker_store(endpoints: "AvailableEndpoints") -> "TrackerStore":
+    """Get `TrackerStore` from `endpoints`.
+
+    Prints an error and exits if no tracker store could be loaded.
+
+    Args:
+        endpoints: `AvailableEndpoints` to initialize the tracker store from.
+
+    Returns:
+        Initialized tracker store.
+
+    """
+    if not endpoints.tracker_store:
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Could not find a `tracker_store` section in the supplied "
+            f"endpoints file. Instructions on how to configure a tracker store "
+            f"can be found here: {DOCS_URL_TRACKER_STORES}. "
+            f"Exiting. "
+        )
+
+    from rasa.core.tracker_store import TrackerStore
+
+    return TrackerStore.create(endpoints.tracker_store)
+
+
+async def _get_event_broker(endpoints: "AvailableEndpoints") -> "EventBroker":
+    """Get `EventBroker` from `endpoints`.
+
+    Prints an error and exits if no event broker could be loaded.
+
+    Args:
+        endpoints: `AvailableEndpoints` to initialize the event broker from.
+
+    Returns:
+        Initialized event broker.
+
+    """
+    from rasa.core.brokers.broker import EventBroker
+
+    broker = await EventBroker.create(endpoints.event_broker)
+
+    if not broker:
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Could not find an `event_broker` section in the supplied "
+            f"endpoints file. Instructions on how to configure an event broker "
+            f"can be found here: {DOCS_URL_EVENT_BROKERS}. Exiting."
+        )
+    return broker
+
+
+def _get_requested_conversation_ids(
+    conversation_ids_arg: Optional[Text] = None,
+) -> Optional[List[Text]]:
+    """Get list of conversation IDs requested as a command-line argument.
+
+    Args:
+        conversation_ids_arg: Value of `--conversation-ids` command-line argument.
+            If provided, this is a string of comma-separated conversation IDs.
+
+    Return:
+        List of conversation IDs requested as a command-line argument.
+        `None` if that argument was left unspecified.
+
+    """
+    if not conversation_ids_arg:
+        return None
+
+    return conversation_ids_arg.split(",")
+
+
+def _assert_max_timestamp_is_greater_than_min_timestamp(
+    args: argparse.Namespace,
+) -> None:
+    """Inspect CLI timestamp parameters.
+
+    Prints an error and exits if a maximum timestamp is provided that is smaller
+    than the provided minimum timestamp.
+
+    Args:
+        args: Command-line arguments to process.
+
+    """
+    min_timestamp = args.minimum_timestamp
+    max_timestamp = args.maximum_timestamp
+
+    if (
+        min_timestamp is not None
+        and max_timestamp is not None
+        and max_timestamp < min_timestamp
+    ):
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Maximum timestamp '{max_timestamp}' is smaller than minimum "
+            f"timestamp '{min_timestamp}'. Exiting."
+        )
+
+
+def _prepare_event_broker(event_broker: "EventBroker") -> None:
+    """Prepares event broker to export tracker events.
+
+    Sets `should_keep_unpublished_messages` flag to `False` if
+    `self.event_broker` is a `PikaEventBroker`.
+
+    If publishing of events fails, the `PikaEventBroker` instance should not keep a
+    list of unpublished messages, so we can retry publishing them. This is because
+    the instance is launched as part of this short-lived export script, meaning the
+    object is destroyed before it might be published.
+
+    In addition, wait until the event broker reports a `ready` state.
+
+    """
+    if isinstance(event_broker, PikaEventBroker):
+        event_broker.should_keep_unpublished_messages = False
+        event_broker.raise_on_failure = True
+
+    if not event_broker.is_ready():
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Event broker of type '{type(event_broker)}' is not ready. Exiting."
+        )
+
+
+def export_trackers(args: argparse.Namespace) -> None:
+    """Export events for a connected tracker store using an event broker.
+
+    Args:
+        args: Command-line arguments to process.
+    """
+    asyncio.run(_export_trackers(args))
+
+
+async def _export_trackers(args: argparse.Namespace) -> None:
+    _assert_max_timestamp_is_greater_than_min_timestamp(args)
+
+    endpoints = rasa.core.utils.read_endpoints_from_path(args.endpoints)
+    tracker_store = _get_tracker_store(endpoints)
+    event_broker = await _get_event_broker(endpoints)
+    _prepare_event_broker(event_broker)
+    requested_conversation_ids = _get_requested_conversation_ids(args.conversation_ids)
+
+    from rasa.core.exporter import Exporter
+
+    exporter = Exporter(
+        tracker_store,
+        event_broker,
+        args.endpoints,
+        requested_conversation_ids,
+        args.minimum_timestamp,
+        args.maximum_timestamp,
+        args.offset_timestamps_by_seconds,
+    )
+
+    try:
+        published_events = await exporter.publish_events()
+        telemetry.track_tracker_export(published_events, tracker_store, event_broker)
+        rasa.shared.utils.cli.print_success(
+            f"Done! Successfully published {published_events} events 🎉"
+        )
+
+    except PublishingError as e:
+        command = _get_continuation_command(exporter, e.timestamp)
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Encountered error while publishing event with timestamp '{e}'. To "
+            f"continue where I left off, run the following command:"
+            f"\n\n\t{command}\n\nExiting."
+        )
+
+    except RasaException as e:
+        rasa.shared.utils.cli.print_error_and_exit(str(e))
+
+
+def _get_continuation_command(exporter: "Exporter", timestamp: float) -> Text:
+    """Build CLI command to continue 'rasa export' where it was interrupted.
+
+    Called when event publishing stops due to an error.
+
+    Args:
+        exporter: Exporter object containing objects relevant for this export.
+        timestamp: Timestamp of the last event attempted to be published.
+
+    """
+    # build CLI command command based on supplied timestamp and options
+    command = "rasa export"
+
+    if exporter.endpoints_path is not None:
+        command += f" --endpoints {exporter.endpoints_path}"
+
+    command += f" --minimum-timestamp {timestamp}"
+
+    if exporter.maximum_timestamp is not None:
+        command += f" --maximum-timestamp {exporter.maximum_timestamp}"
+
+    if exporter.requested_conversation_ids:
+        command += (
+            f" --conversation-ids {','.join(exporter.requested_conversation_ids)}"
+        )
+
+    if exporter.offset_timestamps_by_seconds is not None:
+        command += (
+            f" --offset-timestamps-by-seconds {exporter.offset_timestamps_by_seconds}"
+        )
+
+    return command

rasa/cli/inspect.py

@@ -0,0 +1,75 @@
+import argparse
+import webbrowser
+from asyncio import AbstractEventLoop
+from typing import List, Text
+
+from sanic import Sanic
+
+from rasa import telemetry
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import shell as arguments
+from rasa.core import constants
+from rasa.utils.cli import remove_argument_from_parser
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all inspect parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    inspect_parser = subparsers.add_parser(
+        "inspect",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help=(
+            "Loads your trained model and lets you talk to your "
+            "assistant in the browser."
+        ),
+    )
+    inspect_parser.set_defaults(func=inspect)
+    arguments.set_shell_arguments(inspect_parser)
+
+    # additional argument for voice
+    inspect_parser.add_argument(
+        "--voice", help="Enable voice", action="store_true", default=False
+    )
+
+    # it'd be confusing to expose those arguments to the user,
+    # so we remove them
+    remove_argument_from_parser(inspect_parser, "--credentials")
+    remove_argument_from_parser(inspect_parser, "--connector")
+    remove_argument_from_parser(inspect_parser, "--enable-api")
+
+
+async def open_inspector_in_browser(server_url: Text, voice: bool = False) -> None:
+    """Opens the rasa inspector in the default browser."""
+    channel = "socketio" if not voice else "browser_audio"
+    webbrowser.open(f"{server_url}/webhooks/{channel}/inspect.html")
+
+
+def inspect(args: argparse.Namespace) -> None:
+    """Inspect the bot using the most recent model."""
+    import rasa.cli.run
+
+    async def after_start_hook_open_inspector(_: Sanic, __: AbstractEventLoop) -> None:
+        """Hook to open the browser on server start."""
+        server_url = constants.DEFAULT_SERVER_FORMAT.format("http", args.port)
+        await open_inspector_in_browser(server_url, args.voice)
+
+    # the following arguments are not exposed to the user
+    if args.voice:
+        args.connector = "browser_audio"
+    else:
+        args.connector = "rasa.core.channels.socketio.SocketIOInput"
+    args.enable_api = True
+    args.inspect = True
+    args.credentials = None
+    args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
+
+    telemetry.track_inspect_started(args.connector)
+    rasa.cli.run.run(args)

rasa/cli/interactive.py

@@ -0,0 +1,166 @@
+import argparse
+import logging
+import os
+from pathlib import Path
+from typing import List, Optional, Text, Union
+
+from rasa import model
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import interactive as arguments
+import rasa.cli.train as train
+import rasa.cli.utils
+from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.shared.constants import (
+    ASSISTANT_ID_DEFAULT_VALUE,
+    ASSISTANT_ID_KEY,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_MODELS_PATH,
+)
+from rasa.shared.data import TrainingType
+from rasa.shared.importers.importer import TrainingDataImporter
+import rasa.shared.utils.cli
+import rasa.utils.common
+
+
+logger = logging.getLogger(__name__)
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all interactive cli parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    interactive_parser = subparsers.add_parser(
+        "interactive",
+        conflict_handler="resolve",
+        parents=parents,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Starts an interactive learning session to create new training data for a "
+        "Rasa model by chatting.",
+    )
+    interactive_parser.set_defaults(func=interactive, core_only=False)
+
+    interactive_subparsers = interactive_parser.add_subparsers()
+    interactive_core_parser = interactive_subparsers.add_parser(
+        "core",
+        conflict_handler="resolve",
+        parents=parents,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Starts an interactive learning session model to create new training data "
+        "for a Rasa Core model by chatting. Uses the 'RegexMessageHandler', i.e. "
+        "`/<intent>` input format.",
+    )
+    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) -> None:
+    _set_not_required_args(args)
+    file_importer = TrainingDataImporter.load_from_config(
+        args.config, args.domain, args.data if not args.core_only else [args.stories]
+    )
+
+    if args.model is None:
+        story_graph = file_importer.get_stories()
+        if not story_graph or story_graph.is_empty():
+            rasa.shared.utils.cli.print_error_and_exit(
+                "Could not run interactive learning without either core "
+                "data or a model containing core data."
+            )
+
+        zipped_model: Optional[Union[Text, Path]] = (
+            train.run_core_training(args)
+            if args.core_only
+            else train.run_training(args)
+        )
+        if not zipped_model:
+            rasa.shared.utils.cli.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:
+        validate_assistant_id_key_in_config(file_importer)
+
+        zipped_model = get_provided_model(args.model)
+        if not (zipped_model and os.path.exists(zipped_model)):
+            rasa.shared.utils.cli.print_error_and_exit(
+                f"Interactive learning process cannot be started as no "
+                f"initial model was found at path '{args.model}'.  "
+                f"Use 'rasa train' to train a model."
+            )
+        if not args.skip_visualization:
+            logger.info(f"Loading visualization data from {args.data}.")
+
+    perform_interactive_learning(args, zipped_model, file_importer)
+
+
+def _set_not_required_args(args: argparse.Namespace) -> None:
+    args.fixed_model_name = None
+    args.store_uncompressed = False
+    args.dry_run = False
+    args.skip_validation = True
+    args.fail_on_validation_warnings = False
+    args.validation_max_history = None
+    args.remote_storage = None
+    args.keep_local_model_copy = False
+
+
+def perform_interactive_learning(
+    args: argparse.Namespace,
+    zipped_model: Union[Text, "Path"],
+    file_importer: TrainingDataImporter,
+) -> None:
+    """Performs interactive learning.
+
+    Args:
+        args: Namespace arguments.
+        zipped_model: Path to zipped model.
+        file_importer: File importer which provides the training data and model config.
+    """
+    from rasa.core.train import do_interactive_learning
+
+    args.model = str(zipped_model)
+
+    metadata = LocalModelStorage.metadata_from_archive(zipped_model)
+    if metadata.training_type == TrainingType.NLU:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Can not run interactive learning on an NLU-only model."
+        )
+
+    args.endpoints = rasa.cli.utils.get_validated_path(
+        args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
+    )
+
+    do_interactive_learning(args, file_importer)
+
+
+def get_provided_model(arg_model: Text) -> Optional[Union[Text, Path]]:
+    """Checks model path input and selects model from it."""
+    model_path = rasa.cli.utils.get_validated_path(
+        arg_model, "model", DEFAULT_MODELS_PATH
+    )
+
+    return (
+        model.get_latest_model(model_path) if os.path.isdir(model_path) else model_path
+    )
+
+
+def validate_assistant_id_key_in_config(file_importer: TrainingDataImporter) -> None:
+    """Verifies that config contains a unique value for assistant identifier."""
+    config_data = file_importer.get_config()
+    assistant_id = config_data.get(ASSISTANT_ID_KEY)
+
+    if assistant_id is None or assistant_id == ASSISTANT_ID_DEFAULT_VALUE:
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"The '{ASSISTANT_ID_KEY}' key in the config file is either missing or "
+            f"is set to the default value. Please replace the placeholder default "
+            f"value and re-train the model."
+        )
+    return None

rasa/cli/license.py

@@ -0,0 +1,65 @@
+import argparse
+from typing import List
+
+import rasa.shared.utils.cli
+from rasa.cli import SubParsersAction
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add license parser.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    license_parser = subparsers.add_parser(
+        "license",
+        parents=parents,
+        help="Displays licensing information.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description="Display licensing information.",
+    )
+    license_parser.set_defaults(func=display_license_information)
+
+
+def display_license_information(_: argparse.Namespace) -> None:
+    """Display licensing information to stdout."""
+    rasa.shared.utils.cli.print_info(
+        "By installing and using this software, you agree to be "
+        "bound by the terms and conditions of the Developer Terms "
+        "available at https://rasa.com/developer-terms. "
+        "Please review the Developer Terms carefully before proceeding.\n\n"
+        "Rasa Pro relies on several 3rd-party dependencies. "
+        "The ones below require a license disclorure:\n",
+        PSYCOPG2_LICENSE_DISCLOSURE,
+    )
+
+
+PSYCOPG2_LICENSE_DISCLOSURE = """
+psycopg2 & psycopg2-binary
+--------------------------
+
+psycopg2 and the LGPL
+
+psycopg2 is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+psycopg2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+In addition, as a special exception, the copyright holders give permission to link this program with the OpenSSL library (or with modified versions of OpenSSL that use the same license as OpenSSL), and distribute linked combinations including the two.
+
+You must obey the GNU Lesser General Public License in all respects for all of the code used other than OpenSSL. If you modify file(s) with this exception, you may extend this exception to your version of the file(s), but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. If you delete this exception statement from all source files in the program, then also delete it here.
+
+You should have received a copy of the GNU Lesser General Public License along with psycopg2 (see the doc/ directory.) If not, see https://www.gnu.org/licenses/. Alternative licenses
+
+The following BSD-like license applies (at your option) to the files following the pattern psycopg/adapter*.{h,c} and psycopg/microprotocol*.{h,c}:
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+This notice may not be removed or altered from any source distribution.
+"""  # noqa: E501