rasa-pro 3.13.0.dev7__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/anonymization/anonymization_rule_orchestrator.py

@@ -1,119 +0,0 @@
-import copy
-import json
-import logging
-from typing import Any, Dict, List, Optional, Text
-
-from rasa.anonymization.anonymization_rule_executor import (
-    AnonymizationRuleExecutor,
-    AnonymizationRuleList,
-)
-from rasa.core.brokers.broker import EventBroker
-from rasa.core.brokers.kafka import KafkaEventBroker
-
-logger = logging.getLogger(__name__)
-
-
-class AnonymizationRuleOrchestrator:
-    """Orchestrates the execution of anonymization rules."""
-
-    def __init__(
-        self,
-        event_broker: Optional[EventBroker],
-        anonymization_rule_list: AnonymizationRuleList,
-    ):
-        """Initializes the orchestrator."""
-        self.event_broker = (
-            event_broker if isinstance(event_broker, KafkaEventBroker) else None
-        )
-        self.anonymization_rule_executor = AnonymizationRuleExecutor(
-            anonymization_rule_list
-        )
-
-    def anonymize_event(self, event: Dict[Text, Any]) -> Dict[Text, Any]:
-        """Anonymizes one of the supported event types.
-
-        The supported event types: user, bot, slot, entities.
-        """
-        event_copy = copy.deepcopy(event)
-        event_type = event["event"]
-
-        if event_type == "user" or event_type == "bot":
-            if event["text"] is None:
-                return event_copy
-
-            anonymized_text = self.anonymization_rule_executor.run(event["text"])
-            event_copy["text"] = anonymized_text
-
-            if "parse_data" in event_copy:
-                event_copy["parse_data"]["text"] = anonymized_text
-
-                entities = event_copy["parse_data"]["entities"]
-
-                if entities:
-                    anonymized_entities = self._anonymize_entities(entities)
-                    event_copy["parse_data"]["entities"] = anonymized_entities
-
-        elif event_type == "slot":
-            slot_value = event["value"]
-
-            if slot_value is None:
-                return event_copy
-            elif not isinstance(slot_value, str):
-                slot_value = json.dumps(slot_value)
-
-            anonymized_value = self.anonymization_rule_executor.run(slot_value)
-            event_copy["value"] = anonymized_value
-
-        elif event_type == "entities":
-            entities = event_copy["entities"]
-            anonymized_entities = self._anonymize_entities(entities)
-
-            event_copy["entities"] = anonymized_entities
-        else:
-            logger.debug(f"Unsupported event type for anonymization: {event_type}.")
-
-        return event_copy
-
-    def publish_event(
-        self, anonymized_event: Dict[Text, Any], is_anonymized: bool
-    ) -> None:
-        """Publishes the anonymized event to the event broker."""
-        if self.event_broker is None:
-            return None
-
-        # this assumes that the event broker's topic attribute
-        # is set to the correct anonymization topic
-        if is_anonymized:
-            event_type = anonymized_event["event"]
-            sender_id = anonymized_event["sender_id"]
-            logger.debug(
-                f"Publishing event of type '{event_type}' from "
-                f"sender ID '{sender_id}' to "
-                f"Kafka topic '{self.event_broker.topic}'. "
-                f"The anonymization pipeline used rule named "
-                f"'{self.anonymization_rule_executor.anonymization_rule_list.id}'."
-            )
-
-        self.event_broker.publish(anonymized_event)
-
-    def _anonymize_entities(
-        self, entities: List[Dict[Text, Any]]
-    ) -> List[Dict[Text, Any]]:
-        """Anonymizes entities."""
-        anonymized_entities = []
-
-        for entity in entities:
-            entity_value = entity.get("value")
-
-            if entity_value is not None:
-                value = self.anonymization_rule_executor.run(str(entity_value))
-                entity["value"] = value
-                anonymized_entities.append(entity)
-
-        return anonymized_entities
-
-    def anonymize_log_message(self, message: Text) -> Any:
-        """Anonymizes log messages."""
-        if self.event_broker:
-            return None
-        return self.anonymization_rule_executor.run(message)

rasa/anonymization/schemas/config.yml

@@ -1,47 +0,0 @@
-allowempty: True
-mapping:
-  anonymization:
-    type: "map"
-    mapping:
-      rule_lists:
-        type: "seq"
-        matching: "any"
-        required: True
-        sequence:
-        - type: "map"
-          mapping:
-            id:
-              type: "str"
-              required: True
-            rules:
-              type: "seq"
-              required: True
-              matching: "any"
-              sequence:
-              - type: "map"
-                mapping:
-                  entity:
-                    type: "str"
-                    required: True
-                  substitution:
-                    type: "str"
-                    enum: ["text", "mask", "faker"]
-                    required: False
-                  value:
-                    type: "str"
-                    required: False
-
-      metadata:
-        type: "map"
-        required: True
-        mapping:
-          language:
-            type: "str"
-            required: True
-          model_name:
-            type: "any"
-            required: True
-          model_provider:
-            type: "str"
-            required: True
-            enum: ["spacy", "stanza", "transformers"]

rasa/anonymization/utils.py

@@ -1,118 +0,0 @@
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional, Text
-
-from rasa.shared.exceptions import RasaException, YamlException
-from rasa.shared.utils.yaml import (
-    read_config_file,
-    read_yaml_file,
-    validate_yaml_content_using_schema,
-)
-
-logger = logging.getLogger(__name__)
-SCHEMA_FILE = Path(__file__).parent / "schemas" / "config.yml"
-
-
-def read_endpoint_config(
-    filename: Optional[Text], endpoint_type: Text
-) -> Optional[Dict[Text, Any]]:
-    """Reads a configuration file from disk and extract one config."""
-    if not filename:
-        return None
-
-    try:
-        content = read_config_file(filename, reader_type=["safe", "rt"])
-
-        if content.get(endpoint_type) is None:
-            return None
-
-        return content
-    except FileNotFoundError:
-        logger.error(
-            "Failed to read configuration from {}. No such file.".format(
-                os.path.abspath(filename)
-            ),
-        )
-        return None
-
-
-def extract_anonymization_traits(
-    anonymization_config: Optional[Dict[Text, Any]], endpoint_type: Text
-) -> Dict[Text, Any]:
-    """Extract anonymization traits from the anonymization config.
-
-    Args:
-        anonymization_config: The anonymization config.
-        endpoint_type: The endpoint type.
-
-    Returns:
-        A dictionary containing the anonymization traits.
-    """
-    if not anonymization_config:
-        return {"enabled": False}
-
-    anonymization_value = anonymization_config.get(endpoint_type)
-    if not anonymization_value:
-        logger.debug("Anonymization config found but nothing is defined.")
-        return {"enabled": False}
-
-    try:
-        validate_anonymization_yaml(anonymization_config)
-    except RasaException as exception:
-        logger.debug(exception)
-        return {"enabled": False}
-
-    rule_lists = anonymization_value.get("rule_lists", [])
-
-    traits = {
-        "enabled": True,
-        "metadata": anonymization_value.get("metadata", {}),
-        "number_of_rule_lists": len(rule_lists),
-        "number_of_rules": 0,
-        "substitutions": {
-            "mask": 0,
-            "faker": 0,
-            "text": 0,
-            "not_defined": 0,
-        },
-        "entities": set(),
-    }
-
-    for rule_list in rule_lists:
-        traits["number_of_rules"] += len(rule_list.get("rules", []))
-        for rule in rule_list.get("rules", []):
-            traits["substitutions"][rule.get("substitution", "not_defined")] += 1
-            traits["entities"].add(rule.get("entity"))
-
-    entities = list(traits["entities"])
-    entities.sort()
-    traits["entities"] = entities
-
-    return traits
-
-
-def validate_anonymization_yaml(yaml_content: Dict[Text, Any]) -> None:
-    """Checks if the yaml_content adheres to the anonymization rule schema.
-
-    If the yaml_content is not in the right format, an exception will be raised.
-    """
-    schema = read_yaml_file(SCHEMA_FILE, reader_type=("safe", "rt"))
-    try:
-        validate_yaml_content_using_schema(yaml_content, schema)
-    except YamlException as exception:
-        raise RasaException(
-            f"Invalid configuration for `anonymization_rules` : {exception}"
-        ) from exception
-
-    rule_lists = yaml_content.get("anonymization", {}).get("rule_lists", [])
-
-    rule_set = set()
-    for rule_list in rule_lists:
-        rule_id = rule_list.get("id")
-        if rule_id in rule_set:
-            raise RasaException(
-                f"Invalid configuration for `anonymization_rules` :"
-                f"Duplicate rule id: '{rule_id}' encountered in rule_lists"
-            )
-        rule_set.add(rule_id)