rasa-pro 3.12.0.dev1__py3-none-any.whl

README.md

@@ -0,0 +1,41 @@
+<h1 align="center">Rasa Pro</h1>
+
+<div align="center">
+
+[![Build Status](https://github.com/RasaHQ/rasa-private/workflows/Continuous%20Integration/badge.svg)](https://github.com/RasaHQ/rasa-private/actions)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=RasaHQ_rasa&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=RasaHQ_rasa)
+[![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/rasa-pro/)
+
+</div>
+
+<hr />
+
+
+Rasa Pro is a framework for building scalable, dynamic conversational AI assistants that integrate large language models (LLMs) to enable more contextually aware and agentic interactions. Whether you’re new to conversational AI or an experienced developer, Rasa Pro offers enhanced flexibility, control, and performance for mission-critical applications.
+
+Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features like CALM (Conversational AI with Language Models) and Dialogue Understanding (DU), which enable developers to shift from traditional intent-driven systems to LLM-based agents. This allows for more robust, responsive interactions that adhere strictly to business logic, while reducing risks like prompt injection and minimizing hallucinations.
+
+**Key Features:**
+
+- **Flows for Business Logic:** Easily define business logic through Flows, a simplified way to describe how your AI assistant should handle conversations. Flows help streamline the development process, focusing on key tasks and reducing the complexity involved in managing conversations.
+- **Automatic Conversation Repair:** Ensure seamless interactions by automatically handling interruptions or unexpected inputs. Developers have full control to customize these repairs based on specific use cases.
+- **Customizable and Open:** Fully customizable code that allows developers to modify Rasa Pro to meet specific requirements, ensuring flexibility and adaptability to various conversational AI needs.
+- **Robustness and Control:** Maintain strict adherence to business logic, preventing unwanted behaviors like prompt injection and hallucinations, leading to more reliable responses and secure interactions.
+- **Built-in Security:** Safeguard sensitive data, control access, and ensure secure deployment, essential for production environments that demand high levels of security and compliance.
+
+
+
+A [free developer license](https://rasa.com/docs/rasa-pro/developer-edition/) is available so you can explore and get to know Rasa Pro. For small production deployments, the Extended Developer License allows you to take your assistant live in a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.
+
+To get started right now, you can 
+
+`pip install rasa-pro` 
+
+Check out our 
+
+- [Rasa-pro Quickstart](https://rasa.com/docs/rasa-pro/installation/quickstart/),
+- [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/rasa-pro/calm/),
+- [Rasa Pro / CALM tutorial](https://rasa.com/docs/rasa-pro/tutorial), and
+- [Rasa pro changelog](https://rasa.com/docs/rasa/rasa-pro-changelog/)
+
+for more. Also feel free to reach out to us on the [Rasa forum](https://forum.rasa.com/).

rasa/__init__.py

@@ -0,0 +1,9 @@
+import logging
+
+from rasa import version
+
+# define the version before the other imports since these need it
+__version__ = version.__version__
+
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

rasa/__main__.py

@@ -0,0 +1,177 @@
+import argparse
+from typing import Optional, List
+import structlog
+import os
+import platform
+import sys
+
+from rasa_sdk import __version__ as rasa_sdk_version
+from rasa.constants import MINIMUM_COMPATIBLE_VERSION
+from rasa.utils.log_utils import configure_structlog
+
+import rasa.telemetry
+import rasa.utils.io
+import rasa.utils.tensorflow.environment as tf_env
+from rasa import version
+from rasa.cli import (
+    data,
+    export,
+    interactive,
+    run,
+    scaffold,
+    shell,
+    telemetry,
+    test,
+    train,
+    visualize,
+    x,
+    evaluate,
+    llm_fine_tuning,
+)
+from rasa.cli.arguments.default_arguments import add_logging_options
+from rasa.cli.utils import (
+    parse_last_positional_argument_as_model_path,
+    warn_if_rasa_plus_package_installed,
+    check_if_studio_command,
+)
+from rasa.plugin import plugin_manager
+from rasa.shared.exceptions import RasaException
+from rasa.utils.common import configure_logging_and_warnings
+
+structlogger = structlog.get_logger()
+
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    """Parse all the command line arguments for the training script."""
+    parser = argparse.ArgumentParser(
+        prog="rasa",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description="Rasa command line interface. Rasa allows you to build "
+        "your own conversational assistants 🤖. The 'rasa' command "
+        "allows you to easily run most common commands like "
+        "creating a new bot, training or evaluating models.",
+    )
+
+    parser.add_argument(
+        "--version",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="Print installed Rasa version",
+    )
+
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    add_logging_options(parent_parser)
+    parent_parsers = [parent_parser]
+
+    subparsers = parser.add_subparsers(help="Rasa commands")
+
+    scaffold.add_subparser(subparsers, parents=parent_parsers)
+    run.add_subparser(subparsers, parents=parent_parsers)
+    shell.add_subparser(subparsers, parents=parent_parsers)
+    train.add_subparser(subparsers, parents=parent_parsers)
+    interactive.add_subparser(subparsers, parents=parent_parsers)
+    telemetry.add_subparser(subparsers, parents=parent_parsers)
+    test.add_subparser(subparsers, parents=parent_parsers)
+    visualize.add_subparser(subparsers, parents=parent_parsers)
+    data.add_subparser(subparsers, parents=parent_parsers)
+    export.add_subparser(subparsers, parents=parent_parsers)
+    x.add_subparser(subparsers, parents=parent_parsers)
+    evaluate.add_subparser(subparsers, parents=parent_parsers)
+    llm_fine_tuning.add_subparser(subparsers, parent_parsers)
+    plugin_manager().hook.refine_cli(
+        subparsers=subparsers, parent_parsers=parent_parsers
+    )
+
+    return parser
+
+
+def print_version() -> None:
+    """Prints version information of rasa tooling and python."""
+    from rasa.utils.licensing import get_license_expiration_date
+
+    print(f"Rasa Pro Version  :         {version.__version__}")
+    print(f"Minimum Compatible Version: {MINIMUM_COMPATIBLE_VERSION}")
+    print(f"Rasa SDK Version  :         {rasa_sdk_version}")
+    print(f"Python Version    :         {platform.python_version()}")
+    print(f"Operating System  :         {platform.platform()}")
+    print(f"Python Path       :         {sys.executable}")
+    print(f"License Expires   :         {get_license_expiration_date()}")
+
+
+def main(raw_arguments: Optional[List[str]] = None) -> None:
+    """Run as standalone python application.
+
+    Args:
+        raw_arguments: Arguments to parse. If not provided,
+            arguments will be taken from the command line.
+    """
+    warn_if_rasa_plus_package_installed()
+    parse_last_positional_argument_as_model_path()
+    arg_parser = create_argument_parser()
+    cmdline_arguments = arg_parser.parse_args(raw_arguments)
+
+    log_level = getattr(cmdline_arguments, "loglevel", None)
+    logging_config_file = getattr(cmdline_arguments, "logging_config_file", None)
+    configure_logging_and_warnings(
+        log_level, logging_config_file, warn_only_once=True, filter_repeated_logs=True
+    )
+    # TODO: we shouldn't configure colored logging, since we are using structlog
+    # for logging - should be removed as part of logs cleanup
+    rasa.utils.io.configure_colored_logging(log_level)
+    configure_structlog(log_level)
+
+    tf_env.setup_tf_environment()
+    tf_env.check_deterministic_ops()
+
+    # insert current path in syspath so custom modules are found
+    sys.path.insert(1, os.getcwd())
+
+    try:
+        if hasattr(cmdline_arguments, "func"):
+            is_studio_command = check_if_studio_command()
+
+            if not is_studio_command:
+                result = plugin_manager().hook.configure_commandline(
+                    cmdline_arguments=cmdline_arguments
+                )
+                endpoints_file = result[0] if result else None
+
+            rasa.telemetry.initialize_telemetry()
+            rasa.telemetry.initialize_error_reporting()
+            if not is_studio_command:
+                plugin_manager().hook.init_telemetry(endpoints_file=endpoints_file)
+                plugin_manager().hook.init_managers(endpoints_file=endpoints_file)
+                plugin_manager().hook.init_anonymization_pipeline(
+                    endpoints_file=endpoints_file
+                )
+
+            cmdline_arguments.func(cmdline_arguments)
+        elif hasattr(cmdline_arguments, "version"):
+            print_version()
+        else:
+            # user has not provided a subcommand, let's print the help
+            structlogger.error("cli.no_command", event_info="No command specified.")
+            arg_parser.print_help()
+            sys.exit(1)
+    except RasaException as exc:
+        # these are exceptions we expect to happen (e.g. invalid training data format)
+        # it doesn't make sense to print a stacktrace for these if we are not in
+        # debug mode
+        structlogger.debug(
+            "cli.exception.details",
+            event_info="Failed to run CLI command due to an exception.",
+            exc_info=exc,
+        )
+        structlogger.error("cli.exception.rasa_exception", event_info=f"{exc}")
+        sys.exit(1)
+    except Exception as exc:
+        structlogger.error(
+            "cli.exception.general_exception",
+            event_info=f"{exc.__class__.__name__}: {exc}",
+            exc_info=exc,
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

rasa/anonymization/__init__.py

@@ -0,0 +1,2 @@
+ENV_LOG_LEVEL_PRESIDIO = "LOG_LEVEL_PRESIDIO"
+ENV_LOG_LEVEL_FAKER = "LOG_LEVEL_FAKER"

rasa/anonymization/anonymisation_rule_yaml_reader.py

@@ -0,0 +1,91 @@
+from typing import List, Optional, Text
+
+import pycountry
+from rasa.shared.exceptions import RasaException
+
+from rasa.anonymization.anonymization_rule_executor import (
+    AnonymizationRule,
+    AnonymizationRuleList,
+)
+from rasa.anonymization.utils import (
+    read_endpoint_config,
+    validate_anonymization_yaml,
+)
+
+KEY_ANONYMIZATION_RULES = "anonymization"
+
+
+class AnonymizationRulesYamlReader:
+    """Reads anonymization rules in YAML."""
+
+    def __init__(self, endpoints_filename: Optional[Text] = None) -> None:
+        """Initializes the reader with the endpoints' filename."""
+        self.endpoints_filename = endpoints_filename
+
+    def read_anonymization_rules(self) -> List[AnonymizationRuleList]:
+        """Reads Anonymization rules from a YAML file.
+
+        Returns:
+            Parsed Anonymization rules.
+        """
+        yaml_content = read_endpoint_config(
+            self.endpoints_filename, KEY_ANONYMIZATION_RULES
+        )
+        if yaml_content is None:
+            return []
+
+        validate_anonymization_yaml(yaml_content)
+
+        anonymization_rules = []
+
+        for key, value in yaml_content.items():
+            if key == KEY_ANONYMIZATION_RULES:
+                metadata = value.get("metadata", {})
+                rule_lists = value.get("rule_lists", [])
+
+                lang_code = metadata.get("language")
+                self.validate_language(lang_code)
+
+                model_provider = metadata.get("model_provider")
+                model_name = metadata.get("model_name")
+
+                for rule in rule_lists:
+                    identifier = rule.get("id")
+                    rules = rule.get("rules", [])
+                    rule_list = []
+
+                    for item in rules:
+                        entity_name = item.get("entity")
+                        substitution = item.get("substitution", "mask")
+                        value = item.get("value")
+
+                        rule_obj = AnonymizationRule(
+                            entity_name=entity_name,
+                            substitution=substitution,
+                            value=value,
+                        )
+                        rule_list.append(rule_obj)
+                    anonymization_rule_list_obj = AnonymizationRuleList(
+                        id=identifier,
+                        rule_list=rule_list,
+                        language=lang_code,
+                        model_provider=model_provider,
+                        models=model_name,
+                    )
+
+                    anonymization_rules.append(anonymization_rule_list_obj)
+
+        return anonymization_rules
+
+    def validate_language(self, lang_code: Text) -> None:
+        """Checks if the language is a valid ISO 639-2 code."""
+        language = pycountry.languages.get(alpha_2=lang_code)
+        if language is None:
+            raise RasaException(
+                f"Provided language code '{lang_code}' is invalid. "
+                f"In order to proceed with anonymization, "
+                f"please provide a valid ISO 639-2 language code in "
+                f"the {self.endpoints_filename} file."
+            )
+
+        return None

rasa/anonymization/anonymization_pipeline.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import copy
+import json
+import logging
+import queue
+from typing import Any, Dict, List, Optional, Text
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from rasa.core.brokers.kafka import KafkaEventBroker
+from rasa.shared.core.events import Event
+from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
+
+from rasa.anonymization.anonymisation_rule_yaml_reader import (
+    AnonymizationRulesYamlReader,
+)
+from rasa.anonymization.anonymization_rule_executor import AnonymizationRuleList
+from rasa.anonymization.anonymization_rule_orchestrator import (
+    AnonymizationRuleOrchestrator,
+)
+from rasa.utils.singleton import Singleton
+
+logger = logging.getLogger(__name__)
+
+
+class AnonymizationPipeline:
+    def run(self, event: Dict[Text, Any]) -> None:
+        """Run the anonymization pipeline on the given event.
+
+        Args:
+            event: The event to anonymize
+        """
+        ...
+
+    def log_run(self, data: Any) -> Any:
+        """Anonymize the log data.
+
+        Args:
+            data: log data to anonymize
+
+        Returns:
+            Anonymized log data
+        """
+        ...
+
+    def stop(self) -> None:
+        """Stop the anonymization pipeline."""
+        ...
+
+
+class BackgroundAnonymizationPipeline(AnonymizationPipeline):
+    EVENT_QUEUE_PROCESSING_TIMEOUT_IN_SECONDS = 2.0
+
+    def __init__(self, anonymization_pipeline: AnonymizationPipeline):
+        self.anonymization_pipeline = anonymization_pipeline
+
+        # Order of the initialisation is important
+        # The event queue must be created before the scheduler
+        # The can_consume_event_queue must be set to True before the scheduler starts
+        self.event_queue: queue.Queue = queue.Queue()
+
+        # This flag is used to stop the scheduler
+        self.can_consume_from_event_queue = True
+        self.event_anonymisation_scheduler = BackgroundScheduler()
+        self.event_anonymisation_scheduler.add_job(
+            self._consumer_queue, max_instances=1
+        )
+        self.event_anonymisation_scheduler.start()
+
+    def stop(self) -> None:
+        logger.debug("Shutting down the anonymization pipeline...")
+        self.can_consume_from_event_queue = False
+        self.event_anonymisation_scheduler.shutdown()
+
+    def run(self, event: Dict[Text, Any]) -> None:
+        self.event_queue.put(event)
+
+    def log_run(self, data: Any) -> Any:
+        return self.anonymization_pipeline.log_run(data)
+
+    def _consumer_queue(self) -> None:
+        while self.can_consume_from_event_queue:
+            try:
+                # Wait for 2 seconds for an event to be added to the queue
+                # If no event is added to the queue, continue
+                # This is done to avoid the scheduler to be stuck in the while loop
+                # when we want to stop the scheduler
+                event = self.event_queue.get(
+                    timeout=self.EVENT_QUEUE_PROCESSING_TIMEOUT_IN_SECONDS
+                )
+                self.anonymization_pipeline.run(event)
+                self.event_queue.task_done()
+            except queue.Empty:
+                continue
+
+
+class SyncAnonymizationPipeline(AnonymizationPipeline):
+    """Pipeline for anonymizing events."""
+
+    def __init__(self, orchestrators: List[AnonymizationRuleOrchestrator]) -> None:
+        """Initializes the pipeline."""
+        self.orchestrators = orchestrators
+
+    def stop(self) -> None:
+        pass
+
+    def run(self, event: Dict[Text, Any]) -> None:
+        """Runs the anonymization pipeline."""
+        logger.debug("Running the anonymization pipeline for event...")
+
+        for orchestrator in self.orchestrators:
+            anonymized_event = orchestrator.anonymize_event(event)
+            is_anonymized = True if event != anonymized_event else False
+            orchestrator.publish_event(anonymized_event, is_anonymized)
+
+    def log_run(self, data: Any) -> Any:
+        """Runs the anonymization pipeline for logging."""
+        logger.debug("Running the anonymization pipeline for logs....")
+
+        anonymized_data = None
+
+        # this is to make sure that the original data is not modified
+        data_copy = copy.deepcopy(data)
+
+        for orchestrator in self.orchestrators:
+            # orchestrator for anonymizing logs has its event broker set to None
+            if isinstance(orchestrator.event_broker, KafkaEventBroker):
+                continue
+
+            if isinstance(data_copy, str):
+                anonymized_data = orchestrator.anonymize_log_message(data_copy)
+
+            elif isinstance(data_copy, list):
+                anonymized_data = [
+                    Event.from_parameters(orchestrator.anonymize_event(item.as_dict()))
+                    if isinstance(item, Event)
+                    else orchestrator.anonymize_log_message(str(item["value"]))
+                    if isinstance(item, dict) and item.get("value") is not None
+                    else item
+                    for item in data_copy
+                ]
+
+            elif isinstance(data_copy, dict) and "event" in data_copy:
+                anonymized_data = orchestrator.anonymize_event(data_copy)
+
+            elif isinstance(data_copy, dict):
+                anonymized_data = {}
+
+                for key, value in data_copy.items():
+                    try:
+                        serialized_value = json.dumps(value)
+                    except TypeError as error:
+                        logger.error(
+                            f"Failed to serialize value of type '{type(value)}' "
+                            f"for key '{key}' before anonymization. "
+                            f"Encountered error: {error}. "
+                            f"Setting value to None."
+                        )
+                        serialized_value = None
+
+                    anonymized_data[key] = (
+                        orchestrator.anonymize_log_message(serialized_value)
+                        if serialized_value is not None
+                        else None
+                    )
+
+            else:
+                logger.debug("Unsupported data type for logging anonymization.")
+
+            if anonymized_data:
+                return anonymized_data
+        return data
+
+
+class AnonymizationPipelineProvider(metaclass=Singleton):
+    """Represents a provider for anonymization pipeline."""
+
+    anonymization_pipeline: Optional[AnonymizationPipeline] = None
+
+    def register_anonymization_pipeline(self, pipeline: AnonymizationPipeline) -> None:
+        """Register an anonymization pipeline.
+
+        Args:
+            pipeline: The anonymization pipeline to register.
+        """
+        self.anonymization_pipeline = pipeline
+
+    def get_anonymization_pipeline(self) -> Optional[AnonymizationPipeline]:
+        """Get the anonymization pipeline.
+
+        Returns:
+            The anonymization pipeline.
+        """
+        return self.anonymization_pipeline
+
+
+def load_anonymization_pipeline(endpoints_file: Optional[Text]) -> None:
+    """Creates an anonymization pipeline."""
+    yaml_reader = AnonymizationRulesYamlReader(endpoints_filename=endpoints_file)
+    anonymization_rules = yaml_reader.read_anonymization_rules()
+
+    if anonymization_rules is None:
+        return None
+
+    event_broker_config = read_endpoint_config(
+        endpoints_file, endpoint_type="event_broker"
+    )
+    logging_config = read_endpoint_config(endpoints_file, endpoint_type="logger")
+
+    orchestrators = _load_orchestrators(
+        logging_config, event_broker_config, anonymization_rules
+    )
+
+    if not orchestrators:
+        return None
+
+    pipeline = SyncAnonymizationPipeline(orchestrators)
+    async_anonymization_pipeline = BackgroundAnonymizationPipeline(pipeline)
+    provider = AnonymizationPipelineProvider()
+    provider.register_anonymization_pipeline(async_anonymization_pipeline)
+
+    return None
+
+
+def create_event_broker(
+    topic_name: Text, event_broker_config: EndpointConfig
+) -> Optional[KafkaEventBroker]:
+    """Create a KafkaEventBroker object.
+
+    Returns None if the event broker config is not of type 'kafka'.
+    """
+    if event_broker_config.type != "kafka":
+        logger.warning(
+            f"Unsupported event broker config provided. "
+            f"Expected type 'kafka' but got "
+            f"'{event_broker_config.type}'. "
+            f"Setting event broker to None."
+        )
+        event_broker = None
+    else:
+        logger.debug(f"Setting topic to '{topic_name}'.")
+        event_broker_config.kwargs["topic"] = topic_name
+        event_broker = KafkaEventBroker(
+            event_broker_config.url, **event_broker_config.kwargs
+        )
+
+    return event_broker
+
+
+def _load_orchestrators(
+    logging_config: EndpointConfig,
+    event_broker_config: EndpointConfig,
+    anonymization_rules: List[AnonymizationRuleList],
+) -> List[AnonymizationRuleOrchestrator]:
+    orchestrators = []
+
+    if logging_config:
+        formatter = logging_config.kwargs.get("formatter", "")
+        logging_rule = formatter.get("anonymization_rules")
+
+        for rule_list in anonymization_rules:
+            if rule_list.id == logging_rule:
+                orchestrators.append(AnonymizationRuleOrchestrator(None, rule_list))
+
+    if event_broker_config:
+        anonymization_topics = event_broker_config.kwargs.get(
+            "anonymization_topics", []
+        )
+        visited_topics = []
+
+        for rule_list in anonymization_rules:
+            for topic in anonymization_topics:
+                topic_name = topic.get("name")
+
+                if topic_name in visited_topics:
+                    continue
+
+                if rule_list.id == topic.get("anonymization_rules"):
+                    event_broker = create_event_broker(topic_name, event_broker_config)
+
+                    orchestrators.append(
+                        AnonymizationRuleOrchestrator(event_broker, rule_list)
+                    )
+
+                    visited_topics.append(topic_name)
+    return orchestrators